]> 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
Version number update
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= _core_.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init_core_
1478
1479 #define SWIG_name "_core_"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString FileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632
2633 void wxApp_CleanUp() {
2634 __wxPyCleanup();
2635 }
2636
2637
2638 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2639
2640
2641 SWIGINTERNSHORT int
2642 SWIG_AsCharPtr(PyObject *obj, char **val)
2643 {
2644 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2645 return 1;
2646 }
2647 if (val) {
2648 PyErr_Clear();
2649 SWIG_type_error("char *", obj);
2650 }
2651 return 0;
2652 }
2653
2654
2655 SWIGINTERN PyObject *
2656 SWIG_FromCharPtr(const char* cptr)
2657 {
2658 if (cptr) {
2659 size_t size = strlen(cptr);
2660 if (size > INT_MAX) {
2661 return SWIG_NewPointerObj((char*)(cptr),
2662 SWIG_TypeQuery("char *"), 0);
2663 } else {
2664 if (size != 0) {
2665 return PyString_FromStringAndSize(cptr, size);
2666 } else {
2667 return PyString_FromString(cptr);
2668 }
2669 }
2670 }
2671 Py_INCREF(Py_None);
2672 return Py_None;
2673 }
2674
2675
2676 #ifdef __WXMAC__
2677
2678 // A dummy class that raises an exception if used...
2679 class wxEventLoop
2680 {
2681 public:
2682 wxEventLoop() { wxPyRaiseNotImplemented(); }
2683 int Run() { return 0; }
2684 void Exit(int rc = 0) {}
2685 bool Pending() const { return false; }
2686 bool Dispatch() { return false; }
2687 bool IsRunning() const { return false; }
2688 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2689 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2690 };
2691
2692 #else
2693
2694 #include <wx/evtloop.h>
2695
2696 #endif
2697
2698
2699
2700 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2701 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2702 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2703 static PyObject *wxWindow_GetChildren(wxWindow *self){
2704 wxWindowList& list = self->GetChildren();
2705 return wxPy_ConvertList(&list);
2706 }
2707 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2708 #if wxUSE_HOTKEY
2709 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2710 #else
2711 return false;
2712 #endif
2713 }
2714 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2715
2716
2717
2718 return false;
2719
2720 }
2721 static long wxWindow_GetHandle(wxWindow *self){
2722 return wxPyGetWinHandle(self);
2723 }
2724 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2725 self->AssociateHandle((WXWidget)handle);
2726 }
2727
2728 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2729 return wxWindow::FindWindowById(id, parent);
2730 }
2731
2732 wxWindow* wxFindWindowByName( const wxString& name,
2733 const wxWindow *parent = NULL ) {
2734 return wxWindow::FindWindowByName(name, parent);
2735 }
2736
2737 wxWindow* wxFindWindowByLabel( const wxString& label,
2738 const wxWindow *parent = NULL ) {
2739 return wxWindow::FindWindowByLabel(label, parent);
2740 }
2741
2742
2743 #ifdef __WXMSW__
2744 #include <wx/msw/private.h> // to get wxGetWindowId
2745 #endif
2746
2747
2748 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2749 #ifdef __WXMSW__
2750 WXHWND hWnd = (WXHWND)_hWnd;
2751 long id = wxGetWindowId(hWnd);
2752 wxWindow* win = new wxWindow;
2753 parent->AddChild(win);
2754 win->SetEventHandler(win);
2755 win->SetHWND(hWnd);
2756 win->SetId(id);
2757 win->SubclassWin(hWnd);
2758 win->AdoptAttributesFromHWND();
2759 win->SetupColours();
2760 return win;
2761 #else
2762 wxPyRaiseNotImplemented();
2763 return NULL;
2764 #endif
2765 }
2766
2767
2768 PyObject* GetTopLevelWindows() {
2769 return wxPy_ConvertList(&wxTopLevelWindows);
2770 }
2771
2772
2773 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2774 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2775 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2776
2777 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2778
2779 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2780 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2781 wxMenuItemList& list = self->GetMenuItems();
2782 return wxPy_ConvertList(&list);
2783 }
2784 static const wxString wxPyControlNameStr(wxControlNameStr);
2785 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2786 if (clientData) {
2787 wxPyClientData* data = new wxPyClientData(clientData);
2788 return self->Append(item, data);
2789 } else
2790 return self->Append(item);
2791 }
2792 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2793 if (clientData) {
2794 wxPyClientData* data = new wxPyClientData(clientData);
2795 return self->Insert(item, pos, data);
2796 } else
2797 return self->Insert(item, pos);
2798 }
2799 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2800 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2801 if (data) {
2802 Py_INCREF(data->m_obj);
2803 return data->m_obj;
2804 } else {
2805 Py_INCREF(Py_None);
2806 return Py_None;
2807 }
2808 }
2809 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2810 wxPyClientData* data = new wxPyClientData(clientData);
2811 self->SetClientObject(n, data);
2812 }
2813
2814
2815 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2816 wxPyUserData* data = NULL;
2817 if ( userData ) {
2818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2819 data = new wxPyUserData(userData);
2820 wxPyEndBlockThreads(blocked);
2821 }
2822 return new wxSizerItem(window, proportion, flag, border, data);
2823 }
2824 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2825 wxPyUserData* data = NULL;
2826 if ( userData ) {
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2828 data = new wxPyUserData(userData);
2829 wxPyEndBlockThreads(blocked);
2830 }
2831 return new wxSizerItem(width, height, proportion, flag, border, data);
2832 }
2833 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2834 wxPyUserData* data = NULL;
2835 if ( userData ) {
2836 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2837 data = new wxPyUserData(userData);
2838 wxPyEndBlockThreads(blocked);
2839 }
2840 return new wxSizerItem(sizer, proportion, flag, border, data);
2841 }
2842
2843 #include <float.h>
2844 SWIGINTERN int
2845 SWIG_CheckDoubleInRange(double value, double min_value,
2846 double max_value, const char* errmsg)
2847 {
2848 if (value < min_value) {
2849 if (errmsg) {
2850 PyErr_Format(PyExc_OverflowError,
2851 "value %g is less than %s minimum %g",
2852 value, errmsg, min_value);
2853 }
2854 return 0;
2855 } else if (value > max_value) {
2856 if (errmsg) {
2857 PyErr_Format(PyExc_OverflowError,
2858 "value %g is greater than %s maximum %g",
2859 value, errmsg, max_value);
2860 }
2861 return 0;
2862 }
2863 return 1;
2864 }
2865
2866
2867 SWIGINTERN int
2868 SWIG_AsVal_float(PyObject *obj, float *val)
2869 {
2870 const char* errmsg = val ? "float" : (char*)0;
2871 double v;
2872 if (SWIG_AsVal_double(obj, &v)) {
2873 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2874 if (val) *val = (float)(v);
2875 return 1;
2876 } else {
2877 return 0;
2878 }
2879 } else {
2880 PyErr_Clear();
2881 }
2882 if (val) {
2883 SWIG_type_error(errmsg, obj);
2884 }
2885 return 0;
2886 }
2887
2888
2889 SWIGINTERNSHORT float
2890 SWIG_As_float(PyObject* obj)
2891 {
2892 float v;
2893 if (!SWIG_AsVal_float(obj, &v)) {
2894 /*
2895 this is needed to make valgrind/purify happier.
2896 */
2897 memset((void*)&v, 0, sizeof(float));
2898 }
2899 return v;
2900 }
2901
2902
2903 SWIGINTERNSHORT int
2904 SWIG_Check_float(PyObject* obj)
2905 {
2906 return SWIG_AsVal_float(obj, (float*)0);
2907 }
2908
2909
2910 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2911 #define SWIG_From_float PyFloat_FromDouble
2912 /*@@*/
2913
2914 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2915 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2916 if (data) {
2917 Py_INCREF(data->m_obj);
2918 return data->m_obj;
2919 } else {
2920 Py_INCREF(Py_None);
2921 return Py_None;
2922 }
2923 }
2924
2925 // Figure out the type of the sizer item
2926
2927 struct wxPySizerItemInfo {
2928 wxPySizerItemInfo()
2929 : window(NULL), sizer(NULL), gotSize(false),
2930 size(wxDefaultSize), gotPos(false), pos(-1)
2931 {}
2932
2933 wxWindow* window;
2934 wxSizer* sizer;
2935 bool gotSize;
2936 wxSize size;
2937 bool gotPos;
2938 int pos;
2939 };
2940
2941 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2942
2943 wxPySizerItemInfo info;
2944 wxSize size;
2945 wxSize* sizePtr = &size;
2946
2947 // Find out what the type of the item is
2948 // try wxWindow
2949 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2950 PyErr_Clear();
2951 info.window = NULL;
2952
2953 // try wxSizer
2954 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2955 PyErr_Clear();
2956 info.sizer = NULL;
2957
2958 // try wxSize or (w,h)
2959 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2960 info.size = *sizePtr;
2961 info.gotSize = true;
2962 }
2963
2964 // or a single int
2965 if (checkIdx && PyInt_Check(item)) {
2966 info.pos = PyInt_AsLong(item);
2967 info.gotPos = true;
2968 }
2969 }
2970 }
2971
2972 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2973 // no expected type, figure out what kind of error message to generate
2974 if ( !checkSize && !checkIdx )
2975 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2976 else if ( checkSize && !checkIdx )
2977 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2978 else if ( !checkSize && checkIdx)
2979 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2980 else
2981 // can this one happen?
2982 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2983 }
2984
2985 return info;
2986 }
2987
2988 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2989 if (!self->GetClientObject())
2990 self->SetClientObject(new wxPyOORClientData(_self));
2991 }
2992 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2993
2994 wxPyUserData* data = NULL;
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2997 if ( userData && (info.window || info.sizer || info.gotSize) )
2998 data = new wxPyUserData(userData);
2999 wxPyEndBlockThreads(blocked);
3000
3001 // Now call the real Add method if a valid item type was found
3002 if ( info.window )
3003 return self->Add(info.window, proportion, flag, border, data);
3004 else if ( info.sizer )
3005 return self->Add(info.sizer, proportion, flag, border, data);
3006 else if (info.gotSize)
3007 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3008 proportion, flag, border, data);
3009 else
3010 return NULL;
3011 }
3012 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3013
3014 wxPyUserData* data = NULL;
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3017 if ( userData && (info.window || info.sizer || info.gotSize) )
3018 data = new wxPyUserData(userData);
3019 wxPyEndBlockThreads(blocked);
3020
3021 // Now call the real Insert method if a valid item type was found
3022 if ( info.window )
3023 return self->Insert(before, info.window, proportion, flag, border, data);
3024 else if ( info.sizer )
3025 return self->Insert(before, info.sizer, proportion, flag, border, data);
3026 else if (info.gotSize)
3027 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3028 proportion, flag, border, data);
3029 else
3030 return NULL;
3031 }
3032 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3033
3034 wxPyUserData* data = NULL;
3035 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3036 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3037 if ( userData && (info.window || info.sizer || info.gotSize) )
3038 data = new wxPyUserData(userData);
3039 wxPyEndBlockThreads(blocked);
3040
3041 // Now call the real Prepend method if a valid item type was found
3042 if ( info.window )
3043 return self->Prepend(info.window, proportion, flag, border, data);
3044 else if ( info.sizer )
3045 return self->Prepend(info.sizer, proportion, flag, border, data);
3046 else if (info.gotSize)
3047 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3048 proportion, flag, border, data);
3049 else
3050 return NULL;
3051 }
3052 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3053 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3055 wxPyEndBlockThreads(blocked);
3056 if ( info.window )
3057 return self->Remove(info.window);
3058 else if ( info.sizer )
3059 return self->Remove(info.sizer);
3060 else if ( info.gotPos )
3061 return self->Remove(info.pos);
3062 else
3063 return false;
3064 }
3065 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3066 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3067 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3068 wxPyEndBlockThreads(blocked);
3069 if ( info.window )
3070 return self->Detach(info.window);
3071 else if ( info.sizer )
3072 return self->Detach(info.sizer);
3073 else if ( info.gotPos )
3074 return self->Detach(info.pos);
3075 else
3076 return false;
3077 }
3078 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3080 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3081 wxPyEndBlockThreads(blocked);
3082 if ( info.window )
3083 return self->GetItem(info.window);
3084 else if ( info.sizer )
3085 return self->GetItem(info.sizer);
3086 else if ( info.gotPos )
3087 return self->GetItem(info.pos);
3088 else
3089 return NULL;
3090 }
3091 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3093 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3094 wxPyEndBlockThreads(blocked);
3095 if ( info.window )
3096 self->SetItemMinSize(info.window, size);
3097 else if ( info.sizer )
3098 self->SetItemMinSize(info.sizer, size);
3099 else if ( info.gotPos )
3100 self->SetItemMinSize(info.pos, size);
3101 }
3102 static PyObject *wxSizer_GetChildren(wxSizer *self){
3103 wxSizerItemList& list = self->GetChildren();
3104 return wxPy_ConvertList(&list);
3105 }
3106 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3107 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3108 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3109 wxPyEndBlockThreads(blocked);
3110 if ( info.window )
3111 return self->Show(info.window, show, recursive);
3112 else if ( info.sizer )
3113 return self->Show(info.sizer, show, recursive);
3114 else if ( info.gotPos )
3115 return self->Show(info.pos, show);
3116 else
3117 return false;
3118 }
3119 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3120 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3121 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3122 wxPyEndBlockThreads(blocked);
3123 if ( info.window )
3124 return self->IsShown(info.window);
3125 else if ( info.sizer )
3126 return self->IsShown(info.sizer);
3127 else if ( info.gotPos )
3128 return self->IsShown(info.pos);
3129 else
3130 return false;
3131 }
3132
3133 // See pyclasses.h
3134 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3135 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3136 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3137
3138
3139
3140
3141 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3142 {
3143 if (source == Py_None) {
3144 **obj = wxGBPosition(-1,-1);
3145 return true;
3146 }
3147 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3148 }
3149
3150 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3151 {
3152 if (source == Py_None) {
3153 **obj = wxGBSpan(-1,-1);
3154 return true;
3155 }
3156 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3157 }
3158
3159
3160 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3161 self->SetRow(row);
3162 self->SetCol(col);
3163 }
3164 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3166 PyObject* tup = PyTuple_New(2);
3167 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3168 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3169 wxPyEndBlockThreads(blocked);
3170 return tup;
3171 }
3172 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3173 self->SetRowspan(rowspan);
3174 self->SetColspan(colspan);
3175 }
3176 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3178 PyObject* tup = PyTuple_New(2);
3179 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3180 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3181 wxPyEndBlockThreads(blocked);
3182 return tup;
3183 }
3184 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3185 wxPyUserData* data = NULL;
3186 if ( userData ) {
3187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3188 data = new wxPyUserData(userData);
3189 wxPyEndBlockThreads(blocked);
3190 }
3191 return new wxGBSizerItem(window, pos, span, flag, border, data);
3192 }
3193 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3194 wxPyUserData* data = NULL;
3195 if ( userData ) {
3196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3197 data = new wxPyUserData(userData);
3198 wxPyEndBlockThreads(blocked);
3199 }
3200 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3201 }
3202 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3203 wxPyUserData* data = NULL;
3204 if ( userData ) {
3205 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3206 data = new wxPyUserData(userData);
3207 wxPyEndBlockThreads(blocked);
3208 }
3209 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3210 }
3211 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3212 int row, col;
3213 self->GetEndPos(row, col);
3214 return wxGBPosition(row, col);
3215 }
3216 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3217
3218 wxPyUserData* data = NULL;
3219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3220 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3221 if ( userData && (info.window || info.sizer || info.gotSize) )
3222 data = new wxPyUserData(userData);
3223 wxPyEndBlockThreads(blocked);
3224
3225 // Now call the real Add method if a valid item type was found
3226 if ( info.window )
3227 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3228 else if ( info.sizer )
3229 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3230 else if (info.gotSize)
3231 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3232 pos, span, flag, border, data);
3233 return NULL;
3234 }
3235
3236
3237 #ifdef __cplusplus
3238 extern "C" {
3239 #endif
3240 static int _wrap_EmptyString_set(PyObject *) {
3241 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3242 return 1;
3243 }
3244
3245
3246 static PyObject *_wrap_EmptyString_get(void) {
3247 PyObject *pyobj;
3248
3249 {
3250 #if wxUSE_UNICODE
3251 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3252 #else
3253 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3254 #endif
3255 }
3256 return pyobj;
3257 }
3258
3259
3260 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3261 PyObject *resultobj;
3262 wxObject *arg1 = (wxObject *) 0 ;
3263 wxString result;
3264 PyObject * obj0 = 0 ;
3265 char *kwnames[] = {
3266 (char *) "self", NULL
3267 };
3268
3269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3271 if (SWIG_arg_fail(1)) SWIG_fail;
3272 {
3273 PyThreadState* __tstate = wxPyBeginAllowThreads();
3274 result = wxObject_GetClassName(arg1);
3275
3276 wxPyEndAllowThreads(__tstate);
3277 if (PyErr_Occurred()) SWIG_fail;
3278 }
3279 {
3280 #if wxUSE_UNICODE
3281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3282 #else
3283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3284 #endif
3285 }
3286 return resultobj;
3287 fail:
3288 return NULL;
3289 }
3290
3291
3292 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3293 PyObject *resultobj;
3294 wxObject *arg1 = (wxObject *) 0 ;
3295 PyObject * obj0 = 0 ;
3296 char *kwnames[] = {
3297 (char *) "self", NULL
3298 };
3299
3300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3302 if (SWIG_arg_fail(1)) SWIG_fail;
3303 {
3304 PyThreadState* __tstate = wxPyBeginAllowThreads();
3305 wxObject_Destroy(arg1);
3306
3307 wxPyEndAllowThreads(__tstate);
3308 if (PyErr_Occurred()) SWIG_fail;
3309 }
3310 Py_INCREF(Py_None); resultobj = Py_None;
3311 return resultobj;
3312 fail:
3313 return NULL;
3314 }
3315
3316
3317 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3318 PyObject *obj;
3319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3320 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3321 Py_INCREF(obj);
3322 return Py_BuildValue((char *)"");
3323 }
3324 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3325 PyObject *resultobj;
3326 wxSize *arg1 = (wxSize *) 0 ;
3327 int arg2 ;
3328 PyObject * obj0 = 0 ;
3329 PyObject * obj1 = 0 ;
3330 char *kwnames[] = {
3331 (char *) "self",(char *) "x", NULL
3332 };
3333
3334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3336 if (SWIG_arg_fail(1)) SWIG_fail;
3337 {
3338 arg2 = (int)(SWIG_As_int(obj1));
3339 if (SWIG_arg_fail(2)) SWIG_fail;
3340 }
3341 if (arg1) (arg1)->x = arg2;
3342
3343 Py_INCREF(Py_None); resultobj = Py_None;
3344 return resultobj;
3345 fail:
3346 return NULL;
3347 }
3348
3349
3350 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3351 PyObject *resultobj;
3352 wxSize *arg1 = (wxSize *) 0 ;
3353 int result;
3354 PyObject * obj0 = 0 ;
3355 char *kwnames[] = {
3356 (char *) "self", NULL
3357 };
3358
3359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3361 if (SWIG_arg_fail(1)) SWIG_fail;
3362 result = (int) ((arg1)->x);
3363
3364 {
3365 resultobj = SWIG_From_int((int)(result));
3366 }
3367 return resultobj;
3368 fail:
3369 return NULL;
3370 }
3371
3372
3373 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3374 PyObject *resultobj;
3375 wxSize *arg1 = (wxSize *) 0 ;
3376 int arg2 ;
3377 PyObject * obj0 = 0 ;
3378 PyObject * obj1 = 0 ;
3379 char *kwnames[] = {
3380 (char *) "self",(char *) "y", NULL
3381 };
3382
3383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3385 if (SWIG_arg_fail(1)) SWIG_fail;
3386 {
3387 arg2 = (int)(SWIG_As_int(obj1));
3388 if (SWIG_arg_fail(2)) SWIG_fail;
3389 }
3390 if (arg1) (arg1)->y = arg2;
3391
3392 Py_INCREF(Py_None); resultobj = Py_None;
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 wxSize *arg1 = (wxSize *) 0 ;
3402 int result;
3403 PyObject * obj0 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "self", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3410 if (SWIG_arg_fail(1)) SWIG_fail;
3411 result = (int) ((arg1)->y);
3412
3413 {
3414 resultobj = SWIG_From_int((int)(result));
3415 }
3416 return resultobj;
3417 fail:
3418 return NULL;
3419 }
3420
3421
3422 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3423 PyObject *resultobj;
3424 int arg1 = (int) 0 ;
3425 int arg2 = (int) 0 ;
3426 wxSize *result;
3427 PyObject * obj0 = 0 ;
3428 PyObject * obj1 = 0 ;
3429 char *kwnames[] = {
3430 (char *) "w",(char *) "h", NULL
3431 };
3432
3433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3434 if (obj0) {
3435 {
3436 arg1 = (int)(SWIG_As_int(obj0));
3437 if (SWIG_arg_fail(1)) SWIG_fail;
3438 }
3439 }
3440 if (obj1) {
3441 {
3442 arg2 = (int)(SWIG_As_int(obj1));
3443 if (SWIG_arg_fail(2)) SWIG_fail;
3444 }
3445 }
3446 {
3447 PyThreadState* __tstate = wxPyBeginAllowThreads();
3448 result = (wxSize *)new wxSize(arg1,arg2);
3449
3450 wxPyEndAllowThreads(__tstate);
3451 if (PyErr_Occurred()) SWIG_fail;
3452 }
3453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3454 return resultobj;
3455 fail:
3456 return NULL;
3457 }
3458
3459
3460 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3461 PyObject *resultobj;
3462 wxSize *arg1 = (wxSize *) 0 ;
3463 PyObject * obj0 = 0 ;
3464 char *kwnames[] = {
3465 (char *) "self", NULL
3466 };
3467
3468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3470 if (SWIG_arg_fail(1)) SWIG_fail;
3471 {
3472 PyThreadState* __tstate = wxPyBeginAllowThreads();
3473 delete arg1;
3474
3475 wxPyEndAllowThreads(__tstate);
3476 if (PyErr_Occurred()) SWIG_fail;
3477 }
3478 Py_INCREF(Py_None); resultobj = Py_None;
3479 return resultobj;
3480 fail:
3481 return NULL;
3482 }
3483
3484
3485 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3486 PyObject *resultobj;
3487 wxSize *arg1 = (wxSize *) 0 ;
3488 wxSize *arg2 = 0 ;
3489 bool result;
3490 wxSize temp2 ;
3491 PyObject * obj0 = 0 ;
3492 PyObject * obj1 = 0 ;
3493 char *kwnames[] = {
3494 (char *) "self",(char *) "sz", NULL
3495 };
3496
3497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3499 if (SWIG_arg_fail(1)) SWIG_fail;
3500 {
3501 arg2 = &temp2;
3502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3503 }
3504 {
3505 PyThreadState* __tstate = wxPyBeginAllowThreads();
3506 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3507
3508 wxPyEndAllowThreads(__tstate);
3509 if (PyErr_Occurred()) SWIG_fail;
3510 }
3511 {
3512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3513 }
3514 return resultobj;
3515 fail:
3516 return NULL;
3517 }
3518
3519
3520 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3521 PyObject *resultobj;
3522 wxSize *arg1 = (wxSize *) 0 ;
3523 wxSize *arg2 = 0 ;
3524 bool result;
3525 wxSize temp2 ;
3526 PyObject * obj0 = 0 ;
3527 PyObject * obj1 = 0 ;
3528 char *kwnames[] = {
3529 (char *) "self",(char *) "sz", NULL
3530 };
3531
3532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3534 if (SWIG_arg_fail(1)) SWIG_fail;
3535 {
3536 arg2 = &temp2;
3537 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3538 }
3539 {
3540 PyThreadState* __tstate = wxPyBeginAllowThreads();
3541 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3542
3543 wxPyEndAllowThreads(__tstate);
3544 if (PyErr_Occurred()) SWIG_fail;
3545 }
3546 {
3547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3548 }
3549 return resultobj;
3550 fail:
3551 return NULL;
3552 }
3553
3554
3555 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj;
3557 wxSize *arg1 = (wxSize *) 0 ;
3558 wxSize *arg2 = 0 ;
3559 wxSize result;
3560 wxSize temp2 ;
3561 PyObject * obj0 = 0 ;
3562 PyObject * obj1 = 0 ;
3563 char *kwnames[] = {
3564 (char *) "self",(char *) "sz", NULL
3565 };
3566
3567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(1)) SWIG_fail;
3570 {
3571 arg2 = &temp2;
3572 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3573 }
3574 {
3575 PyThreadState* __tstate = wxPyBeginAllowThreads();
3576 result = (arg1)->operator +((wxSize const &)*arg2);
3577
3578 wxPyEndAllowThreads(__tstate);
3579 if (PyErr_Occurred()) SWIG_fail;
3580 }
3581 {
3582 wxSize * resultptr;
3583 resultptr = new wxSize((wxSize &)(result));
3584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3585 }
3586 return resultobj;
3587 fail:
3588 return NULL;
3589 }
3590
3591
3592 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3593 PyObject *resultobj;
3594 wxSize *arg1 = (wxSize *) 0 ;
3595 wxSize *arg2 = 0 ;
3596 wxSize result;
3597 wxSize temp2 ;
3598 PyObject * obj0 = 0 ;
3599 PyObject * obj1 = 0 ;
3600 char *kwnames[] = {
3601 (char *) "self",(char *) "sz", NULL
3602 };
3603
3604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3606 if (SWIG_arg_fail(1)) SWIG_fail;
3607 {
3608 arg2 = &temp2;
3609 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3610 }
3611 {
3612 PyThreadState* __tstate = wxPyBeginAllowThreads();
3613 result = (arg1)->operator -((wxSize const &)*arg2);
3614
3615 wxPyEndAllowThreads(__tstate);
3616 if (PyErr_Occurred()) SWIG_fail;
3617 }
3618 {
3619 wxSize * resultptr;
3620 resultptr = new wxSize((wxSize &)(result));
3621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3622 }
3623 return resultobj;
3624 fail:
3625 return NULL;
3626 }
3627
3628
3629 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3630 PyObject *resultobj;
3631 wxSize *arg1 = (wxSize *) 0 ;
3632 wxSize *arg2 = 0 ;
3633 wxSize temp2 ;
3634 PyObject * obj0 = 0 ;
3635 PyObject * obj1 = 0 ;
3636 char *kwnames[] = {
3637 (char *) "self",(char *) "sz", NULL
3638 };
3639
3640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3642 if (SWIG_arg_fail(1)) SWIG_fail;
3643 {
3644 arg2 = &temp2;
3645 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3646 }
3647 {
3648 PyThreadState* __tstate = wxPyBeginAllowThreads();
3649 (arg1)->IncTo((wxSize const &)*arg2);
3650
3651 wxPyEndAllowThreads(__tstate);
3652 if (PyErr_Occurred()) SWIG_fail;
3653 }
3654 Py_INCREF(Py_None); resultobj = Py_None;
3655 return resultobj;
3656 fail:
3657 return NULL;
3658 }
3659
3660
3661 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3662 PyObject *resultobj;
3663 wxSize *arg1 = (wxSize *) 0 ;
3664 wxSize *arg2 = 0 ;
3665 wxSize temp2 ;
3666 PyObject * obj0 = 0 ;
3667 PyObject * obj1 = 0 ;
3668 char *kwnames[] = {
3669 (char *) "self",(char *) "sz", NULL
3670 };
3671
3672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3674 if (SWIG_arg_fail(1)) SWIG_fail;
3675 {
3676 arg2 = &temp2;
3677 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3678 }
3679 {
3680 PyThreadState* __tstate = wxPyBeginAllowThreads();
3681 (arg1)->DecTo((wxSize const &)*arg2);
3682
3683 wxPyEndAllowThreads(__tstate);
3684 if (PyErr_Occurred()) SWIG_fail;
3685 }
3686 Py_INCREF(Py_None); resultobj = Py_None;
3687 return resultobj;
3688 fail:
3689 return NULL;
3690 }
3691
3692
3693 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3694 PyObject *resultobj;
3695 wxSize *arg1 = (wxSize *) 0 ;
3696 int arg2 ;
3697 int arg3 ;
3698 PyObject * obj0 = 0 ;
3699 PyObject * obj1 = 0 ;
3700 PyObject * obj2 = 0 ;
3701 char *kwnames[] = {
3702 (char *) "self",(char *) "w",(char *) "h", NULL
3703 };
3704
3705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3707 if (SWIG_arg_fail(1)) SWIG_fail;
3708 {
3709 arg2 = (int)(SWIG_As_int(obj1));
3710 if (SWIG_arg_fail(2)) SWIG_fail;
3711 }
3712 {
3713 arg3 = (int)(SWIG_As_int(obj2));
3714 if (SWIG_arg_fail(3)) SWIG_fail;
3715 }
3716 {
3717 PyThreadState* __tstate = wxPyBeginAllowThreads();
3718 (arg1)->Set(arg2,arg3);
3719
3720 wxPyEndAllowThreads(__tstate);
3721 if (PyErr_Occurred()) SWIG_fail;
3722 }
3723 Py_INCREF(Py_None); resultobj = Py_None;
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
3730 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3731 PyObject *resultobj;
3732 wxSize *arg1 = (wxSize *) 0 ;
3733 int arg2 ;
3734 PyObject * obj0 = 0 ;
3735 PyObject * obj1 = 0 ;
3736 char *kwnames[] = {
3737 (char *) "self",(char *) "w", NULL
3738 };
3739
3740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3742 if (SWIG_arg_fail(1)) SWIG_fail;
3743 {
3744 arg2 = (int)(SWIG_As_int(obj1));
3745 if (SWIG_arg_fail(2)) SWIG_fail;
3746 }
3747 {
3748 PyThreadState* __tstate = wxPyBeginAllowThreads();
3749 (arg1)->SetWidth(arg2);
3750
3751 wxPyEndAllowThreads(__tstate);
3752 if (PyErr_Occurred()) SWIG_fail;
3753 }
3754 Py_INCREF(Py_None); resultobj = Py_None;
3755 return resultobj;
3756 fail:
3757 return NULL;
3758 }
3759
3760
3761 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3762 PyObject *resultobj;
3763 wxSize *arg1 = (wxSize *) 0 ;
3764 int arg2 ;
3765 PyObject * obj0 = 0 ;
3766 PyObject * obj1 = 0 ;
3767 char *kwnames[] = {
3768 (char *) "self",(char *) "h", NULL
3769 };
3770
3771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3773 if (SWIG_arg_fail(1)) SWIG_fail;
3774 {
3775 arg2 = (int)(SWIG_As_int(obj1));
3776 if (SWIG_arg_fail(2)) SWIG_fail;
3777 }
3778 {
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 (arg1)->SetHeight(arg2);
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 Py_INCREF(Py_None); resultobj = Py_None;
3786 return resultobj;
3787 fail:
3788 return NULL;
3789 }
3790
3791
3792 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3793 PyObject *resultobj;
3794 wxSize *arg1 = (wxSize *) 0 ;
3795 int result;
3796 PyObject * obj0 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "self", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3803 if (SWIG_arg_fail(1)) SWIG_fail;
3804 {
3805 PyThreadState* __tstate = wxPyBeginAllowThreads();
3806 result = (int)((wxSize const *)arg1)->GetWidth();
3807
3808 wxPyEndAllowThreads(__tstate);
3809 if (PyErr_Occurred()) SWIG_fail;
3810 }
3811 {
3812 resultobj = SWIG_From_int((int)(result));
3813 }
3814 return resultobj;
3815 fail:
3816 return NULL;
3817 }
3818
3819
3820 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3821 PyObject *resultobj;
3822 wxSize *arg1 = (wxSize *) 0 ;
3823 int result;
3824 PyObject * obj0 = 0 ;
3825 char *kwnames[] = {
3826 (char *) "self", NULL
3827 };
3828
3829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3831 if (SWIG_arg_fail(1)) SWIG_fail;
3832 {
3833 PyThreadState* __tstate = wxPyBeginAllowThreads();
3834 result = (int)((wxSize const *)arg1)->GetHeight();
3835
3836 wxPyEndAllowThreads(__tstate);
3837 if (PyErr_Occurred()) SWIG_fail;
3838 }
3839 {
3840 resultobj = SWIG_From_int((int)(result));
3841 }
3842 return resultobj;
3843 fail:
3844 return NULL;
3845 }
3846
3847
3848 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3849 PyObject *resultobj;
3850 wxSize *arg1 = (wxSize *) 0 ;
3851 bool result;
3852 PyObject * obj0 = 0 ;
3853 char *kwnames[] = {
3854 (char *) "self", NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3859 if (SWIG_arg_fail(1)) SWIG_fail;
3860 {
3861 PyThreadState* __tstate = wxPyBeginAllowThreads();
3862 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3863
3864 wxPyEndAllowThreads(__tstate);
3865 if (PyErr_Occurred()) SWIG_fail;
3866 }
3867 {
3868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3869 }
3870 return resultobj;
3871 fail:
3872 return NULL;
3873 }
3874
3875
3876 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3877 PyObject *resultobj;
3878 wxSize *arg1 = (wxSize *) 0 ;
3879 wxSize *arg2 = 0 ;
3880 wxSize temp2 ;
3881 PyObject * obj0 = 0 ;
3882 PyObject * obj1 = 0 ;
3883 char *kwnames[] = {
3884 (char *) "self",(char *) "size", NULL
3885 };
3886
3887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3889 if (SWIG_arg_fail(1)) SWIG_fail;
3890 {
3891 arg2 = &temp2;
3892 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3893 }
3894 {
3895 PyThreadState* __tstate = wxPyBeginAllowThreads();
3896 (arg1)->SetDefaults((wxSize const &)*arg2);
3897
3898 wxPyEndAllowThreads(__tstate);
3899 if (PyErr_Occurred()) SWIG_fail;
3900 }
3901 Py_INCREF(Py_None); resultobj = Py_None;
3902 return resultobj;
3903 fail:
3904 return NULL;
3905 }
3906
3907
3908 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3909 PyObject *resultobj;
3910 wxSize *arg1 = (wxSize *) 0 ;
3911 PyObject *result;
3912 PyObject * obj0 = 0 ;
3913 char *kwnames[] = {
3914 (char *) "self", NULL
3915 };
3916
3917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3919 if (SWIG_arg_fail(1)) SWIG_fail;
3920 {
3921 PyThreadState* __tstate = wxPyBeginAllowThreads();
3922 result = (PyObject *)wxSize_Get(arg1);
3923
3924 wxPyEndAllowThreads(__tstate);
3925 if (PyErr_Occurred()) SWIG_fail;
3926 }
3927 resultobj = result;
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3935 PyObject *obj;
3936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3937 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3938 Py_INCREF(obj);
3939 return Py_BuildValue((char *)"");
3940 }
3941 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3944 double arg2 ;
3945 PyObject * obj0 = 0 ;
3946 PyObject * obj1 = 0 ;
3947 char *kwnames[] = {
3948 (char *) "self",(char *) "x", NULL
3949 };
3950
3951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3953 if (SWIG_arg_fail(1)) SWIG_fail;
3954 {
3955 arg2 = (double)(SWIG_As_double(obj1));
3956 if (SWIG_arg_fail(2)) SWIG_fail;
3957 }
3958 if (arg1) (arg1)->x = arg2;
3959
3960 Py_INCREF(Py_None); resultobj = Py_None;
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3970 double result;
3971 PyObject * obj0 = 0 ;
3972 char *kwnames[] = {
3973 (char *) "self", NULL
3974 };
3975
3976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3978 if (SWIG_arg_fail(1)) SWIG_fail;
3979 result = (double) ((arg1)->x);
3980
3981 {
3982 resultobj = SWIG_From_double((double)(result));
3983 }
3984 return resultobj;
3985 fail:
3986 return NULL;
3987 }
3988
3989
3990 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3991 PyObject *resultobj;
3992 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3993 double arg2 ;
3994 PyObject * obj0 = 0 ;
3995 PyObject * obj1 = 0 ;
3996 char *kwnames[] = {
3997 (char *) "self",(char *) "y", NULL
3998 };
3999
4000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4002 if (SWIG_arg_fail(1)) SWIG_fail;
4003 {
4004 arg2 = (double)(SWIG_As_double(obj1));
4005 if (SWIG_arg_fail(2)) SWIG_fail;
4006 }
4007 if (arg1) (arg1)->y = arg2;
4008
4009 Py_INCREF(Py_None); resultobj = Py_None;
4010 return resultobj;
4011 fail:
4012 return NULL;
4013 }
4014
4015
4016 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4017 PyObject *resultobj;
4018 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4019 double result;
4020 PyObject * obj0 = 0 ;
4021 char *kwnames[] = {
4022 (char *) "self", NULL
4023 };
4024
4025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4027 if (SWIG_arg_fail(1)) SWIG_fail;
4028 result = (double) ((arg1)->y);
4029
4030 {
4031 resultobj = SWIG_From_double((double)(result));
4032 }
4033 return resultobj;
4034 fail:
4035 return NULL;
4036 }
4037
4038
4039 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4040 PyObject *resultobj;
4041 double arg1 = (double) 0.0 ;
4042 double arg2 = (double) 0.0 ;
4043 wxRealPoint *result;
4044 PyObject * obj0 = 0 ;
4045 PyObject * obj1 = 0 ;
4046 char *kwnames[] = {
4047 (char *) "x",(char *) "y", NULL
4048 };
4049
4050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4051 if (obj0) {
4052 {
4053 arg1 = (double)(SWIG_As_double(obj0));
4054 if (SWIG_arg_fail(1)) SWIG_fail;
4055 }
4056 }
4057 if (obj1) {
4058 {
4059 arg2 = (double)(SWIG_As_double(obj1));
4060 if (SWIG_arg_fail(2)) SWIG_fail;
4061 }
4062 }
4063 {
4064 PyThreadState* __tstate = wxPyBeginAllowThreads();
4065 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4066
4067 wxPyEndAllowThreads(__tstate);
4068 if (PyErr_Occurred()) SWIG_fail;
4069 }
4070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4071 return resultobj;
4072 fail:
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4080 PyObject * obj0 = 0 ;
4081 char *kwnames[] = {
4082 (char *) "self", NULL
4083 };
4084
4085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4087 if (SWIG_arg_fail(1)) SWIG_fail;
4088 {
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 delete arg1;
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 Py_INCREF(Py_None); resultobj = Py_None;
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4105 wxRealPoint *arg2 = 0 ;
4106 bool result;
4107 wxRealPoint temp2 ;
4108 PyObject * obj0 = 0 ;
4109 PyObject * obj1 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "self",(char *) "pt", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4116 if (SWIG_arg_fail(1)) SWIG_fail;
4117 {
4118 arg2 = &temp2;
4119 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 {
4129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4130 }
4131 return resultobj;
4132 fail:
4133 return NULL;
4134 }
4135
4136
4137 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4138 PyObject *resultobj;
4139 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4140 wxRealPoint *arg2 = 0 ;
4141 bool result;
4142 wxRealPoint temp2 ;
4143 PyObject * obj0 = 0 ;
4144 PyObject * obj1 = 0 ;
4145 char *kwnames[] = {
4146 (char *) "self",(char *) "pt", NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4151 if (SWIG_arg_fail(1)) SWIG_fail;
4152 {
4153 arg2 = &temp2;
4154 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4155 }
4156 {
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4159
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 {
4164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4165 }
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4173 PyObject *resultobj;
4174 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4175 wxRealPoint *arg2 = 0 ;
4176 wxRealPoint result;
4177 wxRealPoint temp2 ;
4178 PyObject * obj0 = 0 ;
4179 PyObject * obj1 = 0 ;
4180 char *kwnames[] = {
4181 (char *) "self",(char *) "pt", NULL
4182 };
4183
4184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4186 if (SWIG_arg_fail(1)) SWIG_fail;
4187 {
4188 arg2 = &temp2;
4189 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4190 }
4191 {
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4194
4195 wxPyEndAllowThreads(__tstate);
4196 if (PyErr_Occurred()) SWIG_fail;
4197 }
4198 {
4199 wxRealPoint * resultptr;
4200 resultptr = new wxRealPoint((wxRealPoint &)(result));
4201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4202 }
4203 return resultobj;
4204 fail:
4205 return NULL;
4206 }
4207
4208
4209 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4210 PyObject *resultobj;
4211 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4212 wxRealPoint *arg2 = 0 ;
4213 wxRealPoint result;
4214 wxRealPoint temp2 ;
4215 PyObject * obj0 = 0 ;
4216 PyObject * obj1 = 0 ;
4217 char *kwnames[] = {
4218 (char *) "self",(char *) "pt", NULL
4219 };
4220
4221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4223 if (SWIG_arg_fail(1)) SWIG_fail;
4224 {
4225 arg2 = &temp2;
4226 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4227 }
4228 {
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4231
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 wxRealPoint * resultptr;
4237 resultptr = new wxRealPoint((wxRealPoint &)(result));
4238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4239 }
4240 return resultobj;
4241 fail:
4242 return NULL;
4243 }
4244
4245
4246 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4247 PyObject *resultobj;
4248 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4249 double arg2 ;
4250 double arg3 ;
4251 PyObject * obj0 = 0 ;
4252 PyObject * obj1 = 0 ;
4253 PyObject * obj2 = 0 ;
4254 char *kwnames[] = {
4255 (char *) "self",(char *) "x",(char *) "y", NULL
4256 };
4257
4258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4260 if (SWIG_arg_fail(1)) SWIG_fail;
4261 {
4262 arg2 = (double)(SWIG_As_double(obj1));
4263 if (SWIG_arg_fail(2)) SWIG_fail;
4264 }
4265 {
4266 arg3 = (double)(SWIG_As_double(obj2));
4267 if (SWIG_arg_fail(3)) SWIG_fail;
4268 }
4269 {
4270 PyThreadState* __tstate = wxPyBeginAllowThreads();
4271 wxRealPoint_Set(arg1,arg2,arg3);
4272
4273 wxPyEndAllowThreads(__tstate);
4274 if (PyErr_Occurred()) SWIG_fail;
4275 }
4276 Py_INCREF(Py_None); resultobj = Py_None;
4277 return resultobj;
4278 fail:
4279 return NULL;
4280 }
4281
4282
4283 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4284 PyObject *resultobj;
4285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4286 PyObject *result;
4287 PyObject * obj0 = 0 ;
4288 char *kwnames[] = {
4289 (char *) "self", NULL
4290 };
4291
4292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4294 if (SWIG_arg_fail(1)) SWIG_fail;
4295 {
4296 PyThreadState* __tstate = wxPyBeginAllowThreads();
4297 result = (PyObject *)wxRealPoint_Get(arg1);
4298
4299 wxPyEndAllowThreads(__tstate);
4300 if (PyErr_Occurred()) SWIG_fail;
4301 }
4302 resultobj = result;
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4310 PyObject *obj;
4311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4312 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4313 Py_INCREF(obj);
4314 return Py_BuildValue((char *)"");
4315 }
4316 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4317 PyObject *resultobj;
4318 wxPoint *arg1 = (wxPoint *) 0 ;
4319 int arg2 ;
4320 PyObject * obj0 = 0 ;
4321 PyObject * obj1 = 0 ;
4322 char *kwnames[] = {
4323 (char *) "self",(char *) "x", NULL
4324 };
4325
4326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4328 if (SWIG_arg_fail(1)) SWIG_fail;
4329 {
4330 arg2 = (int)(SWIG_As_int(obj1));
4331 if (SWIG_arg_fail(2)) SWIG_fail;
4332 }
4333 if (arg1) (arg1)->x = arg2;
4334
4335 Py_INCREF(Py_None); resultobj = Py_None;
4336 return resultobj;
4337 fail:
4338 return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4343 PyObject *resultobj;
4344 wxPoint *arg1 = (wxPoint *) 0 ;
4345 int result;
4346 PyObject * obj0 = 0 ;
4347 char *kwnames[] = {
4348 (char *) "self", NULL
4349 };
4350
4351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4353 if (SWIG_arg_fail(1)) SWIG_fail;
4354 result = (int) ((arg1)->x);
4355
4356 {
4357 resultobj = SWIG_From_int((int)(result));
4358 }
4359 return resultobj;
4360 fail:
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 wxPoint *arg1 = (wxPoint *) 0 ;
4368 int arg2 ;
4369 PyObject * obj0 = 0 ;
4370 PyObject * obj1 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "self",(char *) "y", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4377 if (SWIG_arg_fail(1)) SWIG_fail;
4378 {
4379 arg2 = (int)(SWIG_As_int(obj1));
4380 if (SWIG_arg_fail(2)) SWIG_fail;
4381 }
4382 if (arg1) (arg1)->y = arg2;
4383
4384 Py_INCREF(Py_None); resultobj = Py_None;
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 wxPoint *arg1 = (wxPoint *) 0 ;
4394 int result;
4395 PyObject * obj0 = 0 ;
4396 char *kwnames[] = {
4397 (char *) "self", NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4402 if (SWIG_arg_fail(1)) SWIG_fail;
4403 result = (int) ((arg1)->y);
4404
4405 {
4406 resultobj = SWIG_From_int((int)(result));
4407 }
4408 return resultobj;
4409 fail:
4410 return NULL;
4411 }
4412
4413
4414 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4415 PyObject *resultobj;
4416 int arg1 = (int) 0 ;
4417 int arg2 = (int) 0 ;
4418 wxPoint *result;
4419 PyObject * obj0 = 0 ;
4420 PyObject * obj1 = 0 ;
4421 char *kwnames[] = {
4422 (char *) "x",(char *) "y", NULL
4423 };
4424
4425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4426 if (obj0) {
4427 {
4428 arg1 = (int)(SWIG_As_int(obj0));
4429 if (SWIG_arg_fail(1)) SWIG_fail;
4430 }
4431 }
4432 if (obj1) {
4433 {
4434 arg2 = (int)(SWIG_As_int(obj1));
4435 if (SWIG_arg_fail(2)) SWIG_fail;
4436 }
4437 }
4438 {
4439 PyThreadState* __tstate = wxPyBeginAllowThreads();
4440 result = (wxPoint *)new wxPoint(arg1,arg2);
4441
4442 wxPyEndAllowThreads(__tstate);
4443 if (PyErr_Occurred()) SWIG_fail;
4444 }
4445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4446 return resultobj;
4447 fail:
4448 return NULL;
4449 }
4450
4451
4452 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4453 PyObject *resultobj;
4454 wxPoint *arg1 = (wxPoint *) 0 ;
4455 PyObject * obj0 = 0 ;
4456 char *kwnames[] = {
4457 (char *) "self", NULL
4458 };
4459
4460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4462 if (SWIG_arg_fail(1)) SWIG_fail;
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 delete arg1;
4466
4467 wxPyEndAllowThreads(__tstate);
4468 if (PyErr_Occurred()) SWIG_fail;
4469 }
4470 Py_INCREF(Py_None); resultobj = Py_None;
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj;
4479 wxPoint *arg1 = (wxPoint *) 0 ;
4480 wxPoint *arg2 = 0 ;
4481 bool result;
4482 wxPoint temp2 ;
4483 PyObject * obj0 = 0 ;
4484 PyObject * obj1 = 0 ;
4485 char *kwnames[] = {
4486 (char *) "self",(char *) "pt", NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4491 if (SWIG_arg_fail(1)) SWIG_fail;
4492 {
4493 arg2 = &temp2;
4494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4495 }
4496 {
4497 PyThreadState* __tstate = wxPyBeginAllowThreads();
4498 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4499
4500 wxPyEndAllowThreads(__tstate);
4501 if (PyErr_Occurred()) SWIG_fail;
4502 }
4503 {
4504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4505 }
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4513 PyObject *resultobj;
4514 wxPoint *arg1 = (wxPoint *) 0 ;
4515 wxPoint *arg2 = 0 ;
4516 bool result;
4517 wxPoint temp2 ;
4518 PyObject * obj0 = 0 ;
4519 PyObject * obj1 = 0 ;
4520 char *kwnames[] = {
4521 (char *) "self",(char *) "pt", NULL
4522 };
4523
4524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4526 if (SWIG_arg_fail(1)) SWIG_fail;
4527 {
4528 arg2 = &temp2;
4529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4534
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4540 }
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj;
4549 wxPoint *arg1 = (wxPoint *) 0 ;
4550 wxPoint *arg2 = 0 ;
4551 wxPoint result;
4552 wxPoint temp2 ;
4553 PyObject * obj0 = 0 ;
4554 PyObject * obj1 = 0 ;
4555 char *kwnames[] = {
4556 (char *) "self",(char *) "pt", NULL
4557 };
4558
4559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4561 if (SWIG_arg_fail(1)) SWIG_fail;
4562 {
4563 arg2 = &temp2;
4564 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4565 }
4566 {
4567 PyThreadState* __tstate = wxPyBeginAllowThreads();
4568 result = (arg1)->operator +((wxPoint const &)*arg2);
4569
4570 wxPyEndAllowThreads(__tstate);
4571 if (PyErr_Occurred()) SWIG_fail;
4572 }
4573 {
4574 wxPoint * resultptr;
4575 resultptr = new wxPoint((wxPoint &)(result));
4576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4577 }
4578 return resultobj;
4579 fail:
4580 return NULL;
4581 }
4582
4583
4584 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4585 PyObject *resultobj;
4586 wxPoint *arg1 = (wxPoint *) 0 ;
4587 wxPoint *arg2 = 0 ;
4588 wxPoint result;
4589 wxPoint temp2 ;
4590 PyObject * obj0 = 0 ;
4591 PyObject * obj1 = 0 ;
4592 char *kwnames[] = {
4593 (char *) "self",(char *) "pt", NULL
4594 };
4595
4596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4598 if (SWIG_arg_fail(1)) SWIG_fail;
4599 {
4600 arg2 = &temp2;
4601 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4602 }
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 result = (arg1)->operator -((wxPoint const &)*arg2);
4606
4607 wxPyEndAllowThreads(__tstate);
4608 if (PyErr_Occurred()) SWIG_fail;
4609 }
4610 {
4611 wxPoint * resultptr;
4612 resultptr = new wxPoint((wxPoint &)(result));
4613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4614 }
4615 return resultobj;
4616 fail:
4617 return NULL;
4618 }
4619
4620
4621 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4622 PyObject *resultobj;
4623 wxPoint *arg1 = (wxPoint *) 0 ;
4624 wxPoint *arg2 = 0 ;
4625 wxPoint *result;
4626 wxPoint temp2 ;
4627 PyObject * obj0 = 0 ;
4628 PyObject * obj1 = 0 ;
4629 char *kwnames[] = {
4630 (char *) "self",(char *) "pt", NULL
4631 };
4632
4633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4635 if (SWIG_arg_fail(1)) SWIG_fail;
4636 {
4637 arg2 = &temp2;
4638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4639 }
4640 {
4641 PyThreadState* __tstate = wxPyBeginAllowThreads();
4642 {
4643 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4644 result = (wxPoint *) &_result_ref;
4645 }
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj;
4659 wxPoint *arg1 = (wxPoint *) 0 ;
4660 wxPoint *arg2 = 0 ;
4661 wxPoint *result;
4662 wxPoint temp2 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 char *kwnames[] = {
4666 (char *) "self",(char *) "pt", NULL
4667 };
4668
4669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4671 if (SWIG_arg_fail(1)) SWIG_fail;
4672 {
4673 arg2 = &temp2;
4674 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4675 }
4676 {
4677 PyThreadState* __tstate = wxPyBeginAllowThreads();
4678 {
4679 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4680 result = (wxPoint *) &_result_ref;
4681 }
4682
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj;
4695 wxPoint *arg1 = (wxPoint *) 0 ;
4696 long arg2 ;
4697 long arg3 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 PyObject * obj2 = 0 ;
4701 char *kwnames[] = {
4702 (char *) "self",(char *) "x",(char *) "y", NULL
4703 };
4704
4705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4707 if (SWIG_arg_fail(1)) SWIG_fail;
4708 {
4709 arg2 = (long)(SWIG_As_long(obj1));
4710 if (SWIG_arg_fail(2)) SWIG_fail;
4711 }
4712 {
4713 arg3 = (long)(SWIG_As_long(obj2));
4714 if (SWIG_arg_fail(3)) SWIG_fail;
4715 }
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 wxPoint_Set(arg1,arg2,arg3);
4719
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 Py_INCREF(Py_None); resultobj = Py_None;
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj;
4732 wxPoint *arg1 = (wxPoint *) 0 ;
4733 PyObject *result;
4734 PyObject * obj0 = 0 ;
4735 char *kwnames[] = {
4736 (char *) "self", NULL
4737 };
4738
4739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4741 if (SWIG_arg_fail(1)) SWIG_fail;
4742 {
4743 PyThreadState* __tstate = wxPyBeginAllowThreads();
4744 result = (PyObject *)wxPoint_Get(arg1);
4745
4746 wxPyEndAllowThreads(__tstate);
4747 if (PyErr_Occurred()) SWIG_fail;
4748 }
4749 resultobj = result;
4750 return resultobj;
4751 fail:
4752 return NULL;
4753 }
4754
4755
4756 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4757 PyObject *obj;
4758 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4759 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4760 Py_INCREF(obj);
4761 return Py_BuildValue((char *)"");
4762 }
4763 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj;
4765 int arg1 = (int) 0 ;
4766 int arg2 = (int) 0 ;
4767 int arg3 = (int) 0 ;
4768 int arg4 = (int) 0 ;
4769 wxRect *result;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 PyObject * obj2 = 0 ;
4773 PyObject * obj3 = 0 ;
4774 char *kwnames[] = {
4775 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4776 };
4777
4778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4779 if (obj0) {
4780 {
4781 arg1 = (int)(SWIG_As_int(obj0));
4782 if (SWIG_arg_fail(1)) SWIG_fail;
4783 }
4784 }
4785 if (obj1) {
4786 {
4787 arg2 = (int)(SWIG_As_int(obj1));
4788 if (SWIG_arg_fail(2)) SWIG_fail;
4789 }
4790 }
4791 if (obj2) {
4792 {
4793 arg3 = (int)(SWIG_As_int(obj2));
4794 if (SWIG_arg_fail(3)) SWIG_fail;
4795 }
4796 }
4797 if (obj3) {
4798 {
4799 arg4 = (int)(SWIG_As_int(obj3));
4800 if (SWIG_arg_fail(4)) SWIG_fail;
4801 }
4802 }
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4806
4807 wxPyEndAllowThreads(__tstate);
4808 if (PyErr_Occurred()) SWIG_fail;
4809 }
4810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4811 return resultobj;
4812 fail:
4813 return NULL;
4814 }
4815
4816
4817 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4818 PyObject *resultobj;
4819 wxPoint *arg1 = 0 ;
4820 wxPoint *arg2 = 0 ;
4821 wxRect *result;
4822 wxPoint temp1 ;
4823 wxPoint temp2 ;
4824 PyObject * obj0 = 0 ;
4825 PyObject * obj1 = 0 ;
4826 char *kwnames[] = {
4827 (char *) "topLeft",(char *) "bottomRight", NULL
4828 };
4829
4830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4831 {
4832 arg1 = &temp1;
4833 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4834 }
4835 {
4836 arg2 = &temp2;
4837 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4838 }
4839 {
4840 PyThreadState* __tstate = wxPyBeginAllowThreads();
4841 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4842
4843 wxPyEndAllowThreads(__tstate);
4844 if (PyErr_Occurred()) SWIG_fail;
4845 }
4846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4847 return resultobj;
4848 fail:
4849 return NULL;
4850 }
4851
4852
4853 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4854 PyObject *resultobj;
4855 wxPoint *arg1 = 0 ;
4856 wxSize *arg2 = 0 ;
4857 wxRect *result;
4858 wxPoint temp1 ;
4859 wxSize temp2 ;
4860 PyObject * obj0 = 0 ;
4861 PyObject * obj1 = 0 ;
4862 char *kwnames[] = {
4863 (char *) "pos",(char *) "size", NULL
4864 };
4865
4866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4867 {
4868 arg1 = &temp1;
4869 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4870 }
4871 {
4872 arg2 = &temp2;
4873 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4874 }
4875 {
4876 PyThreadState* __tstate = wxPyBeginAllowThreads();
4877 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4878
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj;
4891 wxSize *arg1 = 0 ;
4892 wxRect *result;
4893 wxSize temp1 ;
4894 PyObject * obj0 = 0 ;
4895 char *kwnames[] = {
4896 (char *) "size", NULL
4897 };
4898
4899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4900 {
4901 arg1 = &temp1;
4902 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4903 }
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4907
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4912 return resultobj;
4913 fail:
4914 return NULL;
4915 }
4916
4917
4918 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4919 PyObject *resultobj;
4920 wxRect *arg1 = (wxRect *) 0 ;
4921 PyObject * obj0 = 0 ;
4922 char *kwnames[] = {
4923 (char *) "self", NULL
4924 };
4925
4926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4928 if (SWIG_arg_fail(1)) SWIG_fail;
4929 {
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 delete arg1;
4932
4933 wxPyEndAllowThreads(__tstate);
4934 if (PyErr_Occurred()) SWIG_fail;
4935 }
4936 Py_INCREF(Py_None); resultobj = Py_None;
4937 return resultobj;
4938 fail:
4939 return NULL;
4940 }
4941
4942
4943 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4944 PyObject *resultobj;
4945 wxRect *arg1 = (wxRect *) 0 ;
4946 int result;
4947 PyObject * obj0 = 0 ;
4948 char *kwnames[] = {
4949 (char *) "self", NULL
4950 };
4951
4952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4954 if (SWIG_arg_fail(1)) SWIG_fail;
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 result = (int)((wxRect const *)arg1)->GetX();
4958
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 {
4963 resultobj = SWIG_From_int((int)(result));
4964 }
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4972 PyObject *resultobj;
4973 wxRect *arg1 = (wxRect *) 0 ;
4974 int arg2 ;
4975 PyObject * obj0 = 0 ;
4976 PyObject * obj1 = 0 ;
4977 char *kwnames[] = {
4978 (char *) "self",(char *) "x", NULL
4979 };
4980
4981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4983 if (SWIG_arg_fail(1)) SWIG_fail;
4984 {
4985 arg2 = (int)(SWIG_As_int(obj1));
4986 if (SWIG_arg_fail(2)) SWIG_fail;
4987 }
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 (arg1)->SetX(arg2);
4991
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 Py_INCREF(Py_None); resultobj = Py_None;
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj;
5004 wxRect *arg1 = (wxRect *) 0 ;
5005 int result;
5006 PyObject * obj0 = 0 ;
5007 char *kwnames[] = {
5008 (char *) "self", NULL
5009 };
5010
5011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5013 if (SWIG_arg_fail(1)) SWIG_fail;
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 result = (int)(arg1)->GetY();
5017
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 {
5022 resultobj = SWIG_From_int((int)(result));
5023 }
5024 return resultobj;
5025 fail:
5026 return NULL;
5027 }
5028
5029
5030 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5031 PyObject *resultobj;
5032 wxRect *arg1 = (wxRect *) 0 ;
5033 int arg2 ;
5034 PyObject * obj0 = 0 ;
5035 PyObject * obj1 = 0 ;
5036 char *kwnames[] = {
5037 (char *) "self",(char *) "y", NULL
5038 };
5039
5040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5042 if (SWIG_arg_fail(1)) SWIG_fail;
5043 {
5044 arg2 = (int)(SWIG_As_int(obj1));
5045 if (SWIG_arg_fail(2)) SWIG_fail;
5046 }
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 (arg1)->SetY(arg2);
5050
5051 wxPyEndAllowThreads(__tstate);
5052 if (PyErr_Occurred()) SWIG_fail;
5053 }
5054 Py_INCREF(Py_None); resultobj = Py_None;
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5062 PyObject *resultobj;
5063 wxRect *arg1 = (wxRect *) 0 ;
5064 int result;
5065 PyObject * obj0 = 0 ;
5066 char *kwnames[] = {
5067 (char *) "self", NULL
5068 };
5069
5070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5072 if (SWIG_arg_fail(1)) SWIG_fail;
5073 {
5074 PyThreadState* __tstate = wxPyBeginAllowThreads();
5075 result = (int)((wxRect const *)arg1)->GetWidth();
5076
5077 wxPyEndAllowThreads(__tstate);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 {
5081 resultobj = SWIG_From_int((int)(result));
5082 }
5083 return resultobj;
5084 fail:
5085 return NULL;
5086 }
5087
5088
5089 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5090 PyObject *resultobj;
5091 wxRect *arg1 = (wxRect *) 0 ;
5092 int arg2 ;
5093 PyObject * obj0 = 0 ;
5094 PyObject * obj1 = 0 ;
5095 char *kwnames[] = {
5096 (char *) "self",(char *) "w", NULL
5097 };
5098
5099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5101 if (SWIG_arg_fail(1)) SWIG_fail;
5102 {
5103 arg2 = (int)(SWIG_As_int(obj1));
5104 if (SWIG_arg_fail(2)) SWIG_fail;
5105 }
5106 {
5107 PyThreadState* __tstate = wxPyBeginAllowThreads();
5108 (arg1)->SetWidth(arg2);
5109
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 Py_INCREF(Py_None); resultobj = Py_None;
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5121 PyObject *resultobj;
5122 wxRect *arg1 = (wxRect *) 0 ;
5123 int result;
5124 PyObject * obj0 = 0 ;
5125 char *kwnames[] = {
5126 (char *) "self", NULL
5127 };
5128
5129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5131 if (SWIG_arg_fail(1)) SWIG_fail;
5132 {
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 result = (int)((wxRect const *)arg1)->GetHeight();
5135
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 resultobj = SWIG_From_int((int)(result));
5141 }
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5149 PyObject *resultobj;
5150 wxRect *arg1 = (wxRect *) 0 ;
5151 int arg2 ;
5152 PyObject * obj0 = 0 ;
5153 PyObject * obj1 = 0 ;
5154 char *kwnames[] = {
5155 (char *) "self",(char *) "h", NULL
5156 };
5157
5158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5160 if (SWIG_arg_fail(1)) SWIG_fail;
5161 {
5162 arg2 = (int)(SWIG_As_int(obj1));
5163 if (SWIG_arg_fail(2)) SWIG_fail;
5164 }
5165 {
5166 PyThreadState* __tstate = wxPyBeginAllowThreads();
5167 (arg1)->SetHeight(arg2);
5168
5169 wxPyEndAllowThreads(__tstate);
5170 if (PyErr_Occurred()) SWIG_fail;
5171 }
5172 Py_INCREF(Py_None); resultobj = Py_None;
5173 return resultobj;
5174 fail:
5175 return NULL;
5176 }
5177
5178
5179 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5180 PyObject *resultobj;
5181 wxRect *arg1 = (wxRect *) 0 ;
5182 wxPoint result;
5183 PyObject * obj0 = 0 ;
5184 char *kwnames[] = {
5185 (char *) "self", NULL
5186 };
5187
5188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5190 if (SWIG_arg_fail(1)) SWIG_fail;
5191 {
5192 PyThreadState* __tstate = wxPyBeginAllowThreads();
5193 result = ((wxRect const *)arg1)->GetPosition();
5194
5195 wxPyEndAllowThreads(__tstate);
5196 if (PyErr_Occurred()) SWIG_fail;
5197 }
5198 {
5199 wxPoint * resultptr;
5200 resultptr = new wxPoint((wxPoint &)(result));
5201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5202 }
5203 return resultobj;
5204 fail:
5205 return NULL;
5206 }
5207
5208
5209 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5210 PyObject *resultobj;
5211 wxRect *arg1 = (wxRect *) 0 ;
5212 wxPoint *arg2 = 0 ;
5213 wxPoint temp2 ;
5214 PyObject * obj0 = 0 ;
5215 PyObject * obj1 = 0 ;
5216 char *kwnames[] = {
5217 (char *) "self",(char *) "p", NULL
5218 };
5219
5220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5222 if (SWIG_arg_fail(1)) SWIG_fail;
5223 {
5224 arg2 = &temp2;
5225 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5226 }
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 (arg1)->SetPosition((wxPoint const &)*arg2);
5230
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 Py_INCREF(Py_None); resultobj = Py_None;
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5242 PyObject *resultobj;
5243 wxRect *arg1 = (wxRect *) 0 ;
5244 wxSize result;
5245 PyObject * obj0 = 0 ;
5246 char *kwnames[] = {
5247 (char *) "self", NULL
5248 };
5249
5250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5252 if (SWIG_arg_fail(1)) SWIG_fail;
5253 {
5254 PyThreadState* __tstate = wxPyBeginAllowThreads();
5255 result = ((wxRect const *)arg1)->GetSize();
5256
5257 wxPyEndAllowThreads(__tstate);
5258 if (PyErr_Occurred()) SWIG_fail;
5259 }
5260 {
5261 wxSize * resultptr;
5262 resultptr = new wxSize((wxSize &)(result));
5263 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5264 }
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj;
5273 wxRect *arg1 = (wxRect *) 0 ;
5274 wxSize *arg2 = 0 ;
5275 wxSize temp2 ;
5276 PyObject * obj0 = 0 ;
5277 PyObject * obj1 = 0 ;
5278 char *kwnames[] = {
5279 (char *) "self",(char *) "s", NULL
5280 };
5281
5282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5284 if (SWIG_arg_fail(1)) SWIG_fail;
5285 {
5286 arg2 = &temp2;
5287 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5288 }
5289 {
5290 PyThreadState* __tstate = wxPyBeginAllowThreads();
5291 (arg1)->SetSize((wxSize const &)*arg2);
5292
5293 wxPyEndAllowThreads(__tstate);
5294 if (PyErr_Occurred()) SWIG_fail;
5295 }
5296 Py_INCREF(Py_None); resultobj = Py_None;
5297 return resultobj;
5298 fail:
5299 return NULL;
5300 }
5301
5302
5303 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5304 PyObject *resultobj;
5305 wxRect *arg1 = (wxRect *) 0 ;
5306 bool result;
5307 PyObject * obj0 = 0 ;
5308 char *kwnames[] = {
5309 (char *) "self", NULL
5310 };
5311
5312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5314 if (SWIG_arg_fail(1)) SWIG_fail;
5315 {
5316 PyThreadState* __tstate = wxPyBeginAllowThreads();
5317 result = (bool)((wxRect const *)arg1)->IsEmpty();
5318
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 {
5323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5324 }
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5332 PyObject *resultobj;
5333 wxRect *arg1 = (wxRect *) 0 ;
5334 wxPoint result;
5335 PyObject * obj0 = 0 ;
5336 char *kwnames[] = {
5337 (char *) "self", NULL
5338 };
5339
5340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5342 if (SWIG_arg_fail(1)) SWIG_fail;
5343 {
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 result = ((wxRect const *)arg1)->GetTopLeft();
5346
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 wxPoint * resultptr;
5352 resultptr = new wxPoint((wxPoint &)(result));
5353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5354 }
5355 return resultobj;
5356 fail:
5357 return NULL;
5358 }
5359
5360
5361 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5362 PyObject *resultobj;
5363 wxRect *arg1 = (wxRect *) 0 ;
5364 wxPoint *arg2 = 0 ;
5365 wxPoint temp2 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char *kwnames[] = {
5369 (char *) "self",(char *) "p", NULL
5370 };
5371
5372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5374 if (SWIG_arg_fail(1)) SWIG_fail;
5375 {
5376 arg2 = &temp2;
5377 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5378 }
5379 {
5380 PyThreadState* __tstate = wxPyBeginAllowThreads();
5381 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5382
5383 wxPyEndAllowThreads(__tstate);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 Py_INCREF(Py_None); resultobj = Py_None;
5387 return resultobj;
5388 fail:
5389 return NULL;
5390 }
5391
5392
5393 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5394 PyObject *resultobj;
5395 wxRect *arg1 = (wxRect *) 0 ;
5396 wxPoint result;
5397 PyObject * obj0 = 0 ;
5398 char *kwnames[] = {
5399 (char *) "self", NULL
5400 };
5401
5402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5404 if (SWIG_arg_fail(1)) SWIG_fail;
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 result = ((wxRect const *)arg1)->GetBottomRight();
5408
5409 wxPyEndAllowThreads(__tstate);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 {
5413 wxPoint * resultptr;
5414 resultptr = new wxPoint((wxPoint &)(result));
5415 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5416 }
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5424 PyObject *resultobj;
5425 wxRect *arg1 = (wxRect *) 0 ;
5426 wxPoint *arg2 = 0 ;
5427 wxPoint temp2 ;
5428 PyObject * obj0 = 0 ;
5429 PyObject * obj1 = 0 ;
5430 char *kwnames[] = {
5431 (char *) "self",(char *) "p", NULL
5432 };
5433
5434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5436 if (SWIG_arg_fail(1)) SWIG_fail;
5437 {
5438 arg2 = &temp2;
5439 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5440 }
5441 {
5442 PyThreadState* __tstate = wxPyBeginAllowThreads();
5443 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5444
5445 wxPyEndAllowThreads(__tstate);
5446 if (PyErr_Occurred()) SWIG_fail;
5447 }
5448 Py_INCREF(Py_None); resultobj = Py_None;
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj;
5457 wxRect *arg1 = (wxRect *) 0 ;
5458 int result;
5459 PyObject * obj0 = 0 ;
5460 char *kwnames[] = {
5461 (char *) "self", NULL
5462 };
5463
5464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5466 if (SWIG_arg_fail(1)) SWIG_fail;
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (int)((wxRect const *)arg1)->GetLeft();
5470
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 {
5475 resultobj = SWIG_From_int((int)(result));
5476 }
5477 return resultobj;
5478 fail:
5479 return NULL;
5480 }
5481
5482
5483 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5484 PyObject *resultobj;
5485 wxRect *arg1 = (wxRect *) 0 ;
5486 int result;
5487 PyObject * obj0 = 0 ;
5488 char *kwnames[] = {
5489 (char *) "self", NULL
5490 };
5491
5492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5494 if (SWIG_arg_fail(1)) SWIG_fail;
5495 {
5496 PyThreadState* __tstate = wxPyBeginAllowThreads();
5497 result = (int)((wxRect const *)arg1)->GetTop();
5498
5499 wxPyEndAllowThreads(__tstate);
5500 if (PyErr_Occurred()) SWIG_fail;
5501 }
5502 {
5503 resultobj = SWIG_From_int((int)(result));
5504 }
5505 return resultobj;
5506 fail:
5507 return NULL;
5508 }
5509
5510
5511 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5512 PyObject *resultobj;
5513 wxRect *arg1 = (wxRect *) 0 ;
5514 int result;
5515 PyObject * obj0 = 0 ;
5516 char *kwnames[] = {
5517 (char *) "self", NULL
5518 };
5519
5520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5522 if (SWIG_arg_fail(1)) SWIG_fail;
5523 {
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 result = (int)((wxRect const *)arg1)->GetBottom();
5526
5527 wxPyEndAllowThreads(__tstate);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = SWIG_From_int((int)(result));
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj;
5541 wxRect *arg1 = (wxRect *) 0 ;
5542 int result;
5543 PyObject * obj0 = 0 ;
5544 char *kwnames[] = {
5545 (char *) "self", NULL
5546 };
5547
5548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5550 if (SWIG_arg_fail(1)) SWIG_fail;
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 result = (int)((wxRect const *)arg1)->GetRight();
5554
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 {
5559 resultobj = SWIG_From_int((int)(result));
5560 }
5561 return resultobj;
5562 fail:
5563 return NULL;
5564 }
5565
5566
5567 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5568 PyObject *resultobj;
5569 wxRect *arg1 = (wxRect *) 0 ;
5570 int arg2 ;
5571 PyObject * obj0 = 0 ;
5572 PyObject * obj1 = 0 ;
5573 char *kwnames[] = {
5574 (char *) "self",(char *) "left", NULL
5575 };
5576
5577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5579 if (SWIG_arg_fail(1)) SWIG_fail;
5580 {
5581 arg2 = (int)(SWIG_As_int(obj1));
5582 if (SWIG_arg_fail(2)) SWIG_fail;
5583 }
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 (arg1)->SetLeft(arg2);
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 Py_INCREF(Py_None); resultobj = Py_None;
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj;
5600 wxRect *arg1 = (wxRect *) 0 ;
5601 int arg2 ;
5602 PyObject * obj0 = 0 ;
5603 PyObject * obj1 = 0 ;
5604 char *kwnames[] = {
5605 (char *) "self",(char *) "right", NULL
5606 };
5607
5608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5610 if (SWIG_arg_fail(1)) SWIG_fail;
5611 {
5612 arg2 = (int)(SWIG_As_int(obj1));
5613 if (SWIG_arg_fail(2)) SWIG_fail;
5614 }
5615 {
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 (arg1)->SetRight(arg2);
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 Py_INCREF(Py_None); resultobj = Py_None;
5623 return resultobj;
5624 fail:
5625 return NULL;
5626 }
5627
5628
5629 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5630 PyObject *resultobj;
5631 wxRect *arg1 = (wxRect *) 0 ;
5632 int arg2 ;
5633 PyObject * obj0 = 0 ;
5634 PyObject * obj1 = 0 ;
5635 char *kwnames[] = {
5636 (char *) "self",(char *) "top", NULL
5637 };
5638
5639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5641 if (SWIG_arg_fail(1)) SWIG_fail;
5642 {
5643 arg2 = (int)(SWIG_As_int(obj1));
5644 if (SWIG_arg_fail(2)) SWIG_fail;
5645 }
5646 {
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 (arg1)->SetTop(arg2);
5649
5650 wxPyEndAllowThreads(__tstate);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 Py_INCREF(Py_None); resultobj = Py_None;
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5661 PyObject *resultobj;
5662 wxRect *arg1 = (wxRect *) 0 ;
5663 int arg2 ;
5664 PyObject * obj0 = 0 ;
5665 PyObject * obj1 = 0 ;
5666 char *kwnames[] = {
5667 (char *) "self",(char *) "bottom", NULL
5668 };
5669
5670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5672 if (SWIG_arg_fail(1)) SWIG_fail;
5673 {
5674 arg2 = (int)(SWIG_As_int(obj1));
5675 if (SWIG_arg_fail(2)) SWIG_fail;
5676 }
5677 {
5678 PyThreadState* __tstate = wxPyBeginAllowThreads();
5679 (arg1)->SetBottom(arg2);
5680
5681 wxPyEndAllowThreads(__tstate);
5682 if (PyErr_Occurred()) SWIG_fail;
5683 }
5684 Py_INCREF(Py_None); resultobj = Py_None;
5685 return resultobj;
5686 fail:
5687 return NULL;
5688 }
5689
5690
5691 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5692 PyObject *resultobj;
5693 wxRect *arg1 = (wxRect *) 0 ;
5694 int arg2 ;
5695 int arg3 ;
5696 wxRect *result;
5697 PyObject * obj0 = 0 ;
5698 PyObject * obj1 = 0 ;
5699 PyObject * obj2 = 0 ;
5700 char *kwnames[] = {
5701 (char *) "self",(char *) "dx",(char *) "dy", NULL
5702 };
5703
5704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5706 if (SWIG_arg_fail(1)) SWIG_fail;
5707 {
5708 arg2 = (int)(SWIG_As_int(obj1));
5709 if (SWIG_arg_fail(2)) SWIG_fail;
5710 }
5711 {
5712 arg3 = (int)(SWIG_As_int(obj2));
5713 if (SWIG_arg_fail(3)) SWIG_fail;
5714 }
5715 {
5716 PyThreadState* __tstate = wxPyBeginAllowThreads();
5717 {
5718 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5719 result = (wxRect *) &_result_ref;
5720 }
5721
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj;
5734 wxRect *arg1 = (wxRect *) 0 ;
5735 int arg2 ;
5736 int arg3 ;
5737 wxRect *result;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 PyObject * obj2 = 0 ;
5741 char *kwnames[] = {
5742 (char *) "self",(char *) "dx",(char *) "dy", NULL
5743 };
5744
5745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5747 if (SWIG_arg_fail(1)) SWIG_fail;
5748 {
5749 arg2 = (int)(SWIG_As_int(obj1));
5750 if (SWIG_arg_fail(2)) SWIG_fail;
5751 }
5752 {
5753 arg3 = (int)(SWIG_As_int(obj2));
5754 if (SWIG_arg_fail(3)) SWIG_fail;
5755 }
5756 {
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 {
5759 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5760 result = (wxRect *) &_result_ref;
5761 }
5762
5763 wxPyEndAllowThreads(__tstate);
5764 if (PyErr_Occurred()) SWIG_fail;
5765 }
5766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 wxRect *arg1 = (wxRect *) 0 ;
5776 int arg2 ;
5777 int arg3 ;
5778 PyObject * obj0 = 0 ;
5779 PyObject * obj1 = 0 ;
5780 PyObject * obj2 = 0 ;
5781 char *kwnames[] = {
5782 (char *) "self",(char *) "dx",(char *) "dy", NULL
5783 };
5784
5785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5787 if (SWIG_arg_fail(1)) SWIG_fail;
5788 {
5789 arg2 = (int)(SWIG_As_int(obj1));
5790 if (SWIG_arg_fail(2)) SWIG_fail;
5791 }
5792 {
5793 arg3 = (int)(SWIG_As_int(obj2));
5794 if (SWIG_arg_fail(3)) SWIG_fail;
5795 }
5796 {
5797 PyThreadState* __tstate = wxPyBeginAllowThreads();
5798 (arg1)->Offset(arg2,arg3);
5799
5800 wxPyEndAllowThreads(__tstate);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 Py_INCREF(Py_None); resultobj = Py_None;
5804 return resultobj;
5805 fail:
5806 return NULL;
5807 }
5808
5809
5810 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5811 PyObject *resultobj;
5812 wxRect *arg1 = (wxRect *) 0 ;
5813 wxPoint *arg2 = 0 ;
5814 wxPoint temp2 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char *kwnames[] = {
5818 (char *) "self",(char *) "pt", NULL
5819 };
5820
5821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5823 if (SWIG_arg_fail(1)) SWIG_fail;
5824 {
5825 arg2 = &temp2;
5826 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5827 }
5828 {
5829 PyThreadState* __tstate = wxPyBeginAllowThreads();
5830 (arg1)->Offset((wxPoint const &)*arg2);
5831
5832 wxPyEndAllowThreads(__tstate);
5833 if (PyErr_Occurred()) SWIG_fail;
5834 }
5835 Py_INCREF(Py_None); resultobj = Py_None;
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj;
5844 wxRect *arg1 = (wxRect *) 0 ;
5845 wxRect *arg2 = 0 ;
5846 wxRect result;
5847 wxRect temp2 ;
5848 PyObject * obj0 = 0 ;
5849 PyObject * obj1 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "self",(char *) "rect", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 {
5858 arg2 = &temp2;
5859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5860 }
5861 {
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 result = (arg1)->Intersect((wxRect const &)*arg2);
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 {
5869 wxRect * resultptr;
5870 resultptr = new wxRect((wxRect &)(result));
5871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5872 }
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5880 PyObject *resultobj;
5881 wxRect *arg1 = (wxRect *) 0 ;
5882 wxRect *arg2 = 0 ;
5883 wxRect result;
5884 wxRect temp2 ;
5885 PyObject * obj0 = 0 ;
5886 PyObject * obj1 = 0 ;
5887 char *kwnames[] = {
5888 (char *) "self",(char *) "rect", NULL
5889 };
5890
5891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5893 if (SWIG_arg_fail(1)) SWIG_fail;
5894 {
5895 arg2 = &temp2;
5896 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5897 }
5898 {
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 result = (arg1)->Union((wxRect const &)*arg2);
5901
5902 wxPyEndAllowThreads(__tstate);
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 {
5906 wxRect * resultptr;
5907 resultptr = new wxRect((wxRect &)(result));
5908 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5909 }
5910 return resultobj;
5911 fail:
5912 return NULL;
5913 }
5914
5915
5916 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj;
5918 wxRect *arg1 = (wxRect *) 0 ;
5919 wxRect *arg2 = 0 ;
5920 wxRect result;
5921 wxRect temp2 ;
5922 PyObject * obj0 = 0 ;
5923 PyObject * obj1 = 0 ;
5924 char *kwnames[] = {
5925 (char *) "self",(char *) "rect", NULL
5926 };
5927
5928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5930 if (SWIG_arg_fail(1)) SWIG_fail;
5931 {
5932 arg2 = &temp2;
5933 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5934 }
5935 {
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5938
5939 wxPyEndAllowThreads(__tstate);
5940 if (PyErr_Occurred()) SWIG_fail;
5941 }
5942 {
5943 wxRect * resultptr;
5944 resultptr = new wxRect((wxRect &)(result));
5945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5946 }
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj;
5955 wxRect *arg1 = (wxRect *) 0 ;
5956 wxRect *arg2 = 0 ;
5957 wxRect *result;
5958 wxRect temp2 ;
5959 PyObject * obj0 = 0 ;
5960 PyObject * obj1 = 0 ;
5961 char *kwnames[] = {
5962 (char *) "self",(char *) "rect", NULL
5963 };
5964
5965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5967 if (SWIG_arg_fail(1)) SWIG_fail;
5968 {
5969 arg2 = &temp2;
5970 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5971 }
5972 {
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 {
5975 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5976 result = (wxRect *) &_result_ref;
5977 }
5978
5979 wxPyEndAllowThreads(__tstate);
5980 if (PyErr_Occurred()) SWIG_fail;
5981 }
5982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5983 return resultobj;
5984 fail:
5985 return NULL;
5986 }
5987
5988
5989 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5990 PyObject *resultobj;
5991 wxRect *arg1 = (wxRect *) 0 ;
5992 wxRect *arg2 = 0 ;
5993 bool result;
5994 wxRect temp2 ;
5995 PyObject * obj0 = 0 ;
5996 PyObject * obj1 = 0 ;
5997 char *kwnames[] = {
5998 (char *) "self",(char *) "rect", NULL
5999 };
6000
6001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6003 if (SWIG_arg_fail(1)) SWIG_fail;
6004 {
6005 arg2 = &temp2;
6006 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6007 }
6008 {
6009 PyThreadState* __tstate = wxPyBeginAllowThreads();
6010 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6011
6012 wxPyEndAllowThreads(__tstate);
6013 if (PyErr_Occurred()) SWIG_fail;
6014 }
6015 {
6016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6017 }
6018 return resultobj;
6019 fail:
6020 return NULL;
6021 }
6022
6023
6024 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6025 PyObject *resultobj;
6026 wxRect *arg1 = (wxRect *) 0 ;
6027 wxRect *arg2 = 0 ;
6028 bool result;
6029 wxRect temp2 ;
6030 PyObject * obj0 = 0 ;
6031 PyObject * obj1 = 0 ;
6032 char *kwnames[] = {
6033 (char *) "self",(char *) "rect", NULL
6034 };
6035
6036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6038 if (SWIG_arg_fail(1)) SWIG_fail;
6039 {
6040 arg2 = &temp2;
6041 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6042 }
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6046
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 {
6051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6052 }
6053 return resultobj;
6054 fail:
6055 return NULL;
6056 }
6057
6058
6059 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6060 PyObject *resultobj;
6061 wxRect *arg1 = (wxRect *) 0 ;
6062 int arg2 ;
6063 int arg3 ;
6064 bool result;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 PyObject * obj2 = 0 ;
6068 char *kwnames[] = {
6069 (char *) "self",(char *) "x",(char *) "y", NULL
6070 };
6071
6072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6074 if (SWIG_arg_fail(1)) SWIG_fail;
6075 {
6076 arg2 = (int)(SWIG_As_int(obj1));
6077 if (SWIG_arg_fail(2)) SWIG_fail;
6078 }
6079 {
6080 arg3 = (int)(SWIG_As_int(obj2));
6081 if (SWIG_arg_fail(3)) SWIG_fail;
6082 }
6083 {
6084 PyThreadState* __tstate = wxPyBeginAllowThreads();
6085 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6086
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 {
6091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6092 }
6093 return resultobj;
6094 fail:
6095 return NULL;
6096 }
6097
6098
6099 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6100 PyObject *resultobj;
6101 wxRect *arg1 = (wxRect *) 0 ;
6102 wxPoint *arg2 = 0 ;
6103 bool result;
6104 wxPoint temp2 ;
6105 PyObject * obj0 = 0 ;
6106 PyObject * obj1 = 0 ;
6107 char *kwnames[] = {
6108 (char *) "self",(char *) "pt", NULL
6109 };
6110
6111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6113 if (SWIG_arg_fail(1)) SWIG_fail;
6114 {
6115 arg2 = &temp2;
6116 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6117 }
6118 {
6119 PyThreadState* __tstate = wxPyBeginAllowThreads();
6120 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6121
6122 wxPyEndAllowThreads(__tstate);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 {
6126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6127 }
6128 return resultobj;
6129 fail:
6130 return NULL;
6131 }
6132
6133
6134 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6135 PyObject *resultobj;
6136 wxRect *arg1 = (wxRect *) 0 ;
6137 wxRect *arg2 = 0 ;
6138 bool result;
6139 wxRect temp2 ;
6140 PyObject * obj0 = 0 ;
6141 PyObject * obj1 = 0 ;
6142 char *kwnames[] = {
6143 (char *) "self",(char *) "rect", NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 {
6150 arg2 = &temp2;
6151 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6152 }
6153 {
6154 PyThreadState* __tstate = wxPyBeginAllowThreads();
6155 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6156
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 {
6161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6162 }
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 wxRect *arg1 = (wxRect *) 0 ;
6172 int arg2 ;
6173 PyObject * obj0 = 0 ;
6174 PyObject * obj1 = 0 ;
6175 char *kwnames[] = {
6176 (char *) "self",(char *) "x", NULL
6177 };
6178
6179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 {
6183 arg2 = (int)(SWIG_As_int(obj1));
6184 if (SWIG_arg_fail(2)) SWIG_fail;
6185 }
6186 if (arg1) (arg1)->x = arg2;
6187
6188 Py_INCREF(Py_None); resultobj = Py_None;
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj;
6197 wxRect *arg1 = (wxRect *) 0 ;
6198 int result;
6199 PyObject * obj0 = 0 ;
6200 char *kwnames[] = {
6201 (char *) "self", NULL
6202 };
6203
6204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6206 if (SWIG_arg_fail(1)) SWIG_fail;
6207 result = (int) ((arg1)->x);
6208
6209 {
6210 resultobj = SWIG_From_int((int)(result));
6211 }
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj;
6220 wxRect *arg1 = (wxRect *) 0 ;
6221 int arg2 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 char *kwnames[] = {
6225 (char *) "self",(char *) "y", NULL
6226 };
6227
6228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6230 if (SWIG_arg_fail(1)) SWIG_fail;
6231 {
6232 arg2 = (int)(SWIG_As_int(obj1));
6233 if (SWIG_arg_fail(2)) SWIG_fail;
6234 }
6235 if (arg1) (arg1)->y = arg2;
6236
6237 Py_INCREF(Py_None); resultobj = Py_None;
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6245 PyObject *resultobj;
6246 wxRect *arg1 = (wxRect *) 0 ;
6247 int result;
6248 PyObject * obj0 = 0 ;
6249 char *kwnames[] = {
6250 (char *) "self", NULL
6251 };
6252
6253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6255 if (SWIG_arg_fail(1)) SWIG_fail;
6256 result = (int) ((arg1)->y);
6257
6258 {
6259 resultobj = SWIG_From_int((int)(result));
6260 }
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int arg2 ;
6271 PyObject * obj0 = 0 ;
6272 PyObject * obj1 = 0 ;
6273 char *kwnames[] = {
6274 (char *) "self",(char *) "width", NULL
6275 };
6276
6277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 {
6281 arg2 = (int)(SWIG_As_int(obj1));
6282 if (SWIG_arg_fail(2)) SWIG_fail;
6283 }
6284 if (arg1) (arg1)->width = arg2;
6285
6286 Py_INCREF(Py_None); resultobj = Py_None;
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj;
6295 wxRect *arg1 = (wxRect *) 0 ;
6296 int result;
6297 PyObject * obj0 = 0 ;
6298 char *kwnames[] = {
6299 (char *) "self", NULL
6300 };
6301
6302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6304 if (SWIG_arg_fail(1)) SWIG_fail;
6305 result = (int) ((arg1)->width);
6306
6307 {
6308 resultobj = SWIG_From_int((int)(result));
6309 }
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6317 PyObject *resultobj;
6318 wxRect *arg1 = (wxRect *) 0 ;
6319 int arg2 ;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self",(char *) "height", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 arg2 = (int)(SWIG_As_int(obj1));
6331 if (SWIG_arg_fail(2)) SWIG_fail;
6332 }
6333 if (arg1) (arg1)->height = arg2;
6334
6335 Py_INCREF(Py_None); resultobj = Py_None;
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 int result;
6346 PyObject * obj0 = 0 ;
6347 char *kwnames[] = {
6348 (char *) "self", NULL
6349 };
6350
6351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6353 if (SWIG_arg_fail(1)) SWIG_fail;
6354 result = (int) ((arg1)->height);
6355
6356 {
6357 resultobj = SWIG_From_int((int)(result));
6358 }
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj;
6367 wxRect *arg1 = (wxRect *) 0 ;
6368 int arg2 = (int) 0 ;
6369 int arg3 = (int) 0 ;
6370 int arg4 = (int) 0 ;
6371 int arg5 = (int) 0 ;
6372 PyObject * obj0 = 0 ;
6373 PyObject * obj1 = 0 ;
6374 PyObject * obj2 = 0 ;
6375 PyObject * obj3 = 0 ;
6376 PyObject * obj4 = 0 ;
6377 char *kwnames[] = {
6378 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6379 };
6380
6381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6383 if (SWIG_arg_fail(1)) SWIG_fail;
6384 if (obj1) {
6385 {
6386 arg2 = (int)(SWIG_As_int(obj1));
6387 if (SWIG_arg_fail(2)) SWIG_fail;
6388 }
6389 }
6390 if (obj2) {
6391 {
6392 arg3 = (int)(SWIG_As_int(obj2));
6393 if (SWIG_arg_fail(3)) SWIG_fail;
6394 }
6395 }
6396 if (obj3) {
6397 {
6398 arg4 = (int)(SWIG_As_int(obj3));
6399 if (SWIG_arg_fail(4)) SWIG_fail;
6400 }
6401 }
6402 if (obj4) {
6403 {
6404 arg5 = (int)(SWIG_As_int(obj4));
6405 if (SWIG_arg_fail(5)) SWIG_fail;
6406 }
6407 }
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6411
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 Py_INCREF(Py_None); resultobj = Py_None;
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 PyObject *result;
6426 PyObject * obj0 = 0 ;
6427 char *kwnames[] = {
6428 (char *) "self", NULL
6429 };
6430
6431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6433 if (SWIG_arg_fail(1)) SWIG_fail;
6434 {
6435 PyThreadState* __tstate = wxPyBeginAllowThreads();
6436 result = (PyObject *)wxRect_Get(arg1);
6437
6438 wxPyEndAllowThreads(__tstate);
6439 if (PyErr_Occurred()) SWIG_fail;
6440 }
6441 resultobj = result;
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6449 PyObject *obj;
6450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6451 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6452 Py_INCREF(obj);
6453 return Py_BuildValue((char *)"");
6454 }
6455 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj;
6457 wxRect *arg1 = (wxRect *) 0 ;
6458 wxRect *arg2 = (wxRect *) 0 ;
6459 PyObject *result;
6460 PyObject * obj0 = 0 ;
6461 PyObject * obj1 = 0 ;
6462 char *kwnames[] = {
6463 (char *) "r1",(char *) "r2", NULL
6464 };
6465
6466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6468 if (SWIG_arg_fail(1)) SWIG_fail;
6469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6470 if (SWIG_arg_fail(2)) SWIG_fail;
6471 {
6472 if (!wxPyCheckForApp()) SWIG_fail;
6473 PyThreadState* __tstate = wxPyBeginAllowThreads();
6474 result = (PyObject *)wxIntersectRect(arg1,arg2);
6475
6476 wxPyEndAllowThreads(__tstate);
6477 if (PyErr_Occurred()) SWIG_fail;
6478 }
6479 resultobj = result;
6480 return resultobj;
6481 fail:
6482 return NULL;
6483 }
6484
6485
6486 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6487 PyObject *resultobj;
6488 double arg1 = (double) 0.0 ;
6489 double arg2 = (double) 0.0 ;
6490 wxPoint2D *result;
6491 PyObject * obj0 = 0 ;
6492 PyObject * obj1 = 0 ;
6493 char *kwnames[] = {
6494 (char *) "x",(char *) "y", NULL
6495 };
6496
6497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6498 if (obj0) {
6499 {
6500 arg1 = (double)(SWIG_As_double(obj0));
6501 if (SWIG_arg_fail(1)) SWIG_fail;
6502 }
6503 }
6504 if (obj1) {
6505 {
6506 arg2 = (double)(SWIG_As_double(obj1));
6507 if (SWIG_arg_fail(2)) SWIG_fail;
6508 }
6509 }
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6513
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxPoint2D *arg1 = 0 ;
6527 wxPoint2D *result;
6528 wxPoint2D temp1 ;
6529 PyObject * obj0 = 0 ;
6530 char *kwnames[] = {
6531 (char *) "pt", NULL
6532 };
6533
6534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6535 {
6536 arg1 = &temp1;
6537 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6538 }
6539 {
6540 PyThreadState* __tstate = wxPyBeginAllowThreads();
6541 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6542
6543 wxPyEndAllowThreads(__tstate);
6544 if (PyErr_Occurred()) SWIG_fail;
6545 }
6546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj;
6555 wxPoint *arg1 = 0 ;
6556 wxPoint2D *result;
6557 wxPoint temp1 ;
6558 PyObject * obj0 = 0 ;
6559 char *kwnames[] = {
6560 (char *) "pt", NULL
6561 };
6562
6563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6564 {
6565 arg1 = &temp1;
6566 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6567 }
6568 {
6569 PyThreadState* __tstate = wxPyBeginAllowThreads();
6570 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6571
6572 wxPyEndAllowThreads(__tstate);
6573 if (PyErr_Occurred()) SWIG_fail;
6574 }
6575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6576 return resultobj;
6577 fail:
6578 return NULL;
6579 }
6580
6581
6582 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6583 PyObject *resultobj;
6584 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6585 int *arg2 = (int *) 0 ;
6586 int *arg3 = (int *) 0 ;
6587 int temp2 ;
6588 int res2 = 0 ;
6589 int temp3 ;
6590 int res3 = 0 ;
6591 PyObject * obj0 = 0 ;
6592 char *kwnames[] = {
6593 (char *) "self", NULL
6594 };
6595
6596 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6597 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6600 if (SWIG_arg_fail(1)) SWIG_fail;
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6604
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 Py_INCREF(Py_None); resultobj = Py_None;
6609 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6610 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6611 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6612 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6622 int *arg2 = (int *) 0 ;
6623 int *arg3 = (int *) 0 ;
6624 int temp2 ;
6625 int res2 = 0 ;
6626 int temp3 ;
6627 int res3 = 0 ;
6628 PyObject * obj0 = 0 ;
6629 char *kwnames[] = {
6630 (char *) "self", NULL
6631 };
6632
6633 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6634 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6641
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 Py_INCREF(Py_None); resultobj = Py_None;
6646 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6647 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6648 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6649 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj;
6658 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6659 double result;
6660 PyObject * obj0 = 0 ;
6661 char *kwnames[] = {
6662 (char *) "self", NULL
6663 };
6664
6665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6667 if (SWIG_arg_fail(1)) SWIG_fail;
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6671
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 {
6676 resultobj = SWIG_From_double((double)(result));
6677 }
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6685 PyObject *resultobj;
6686 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6687 double result;
6688 PyObject * obj0 = 0 ;
6689 char *kwnames[] = {
6690 (char *) "self", NULL
6691 };
6692
6693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6695 if (SWIG_arg_fail(1)) SWIG_fail;
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6699
6700 wxPyEndAllowThreads(__tstate);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 {
6704 resultobj = SWIG_From_double((double)(result));
6705 }
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj;
6714 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6715 double arg2 ;
6716 PyObject * obj0 = 0 ;
6717 PyObject * obj1 = 0 ;
6718 char *kwnames[] = {
6719 (char *) "self",(char *) "length", NULL
6720 };
6721
6722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6724 if (SWIG_arg_fail(1)) SWIG_fail;
6725 {
6726 arg2 = (double)(SWIG_As_double(obj1));
6727 if (SWIG_arg_fail(2)) SWIG_fail;
6728 }
6729 {
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 (arg1)->SetVectorLength(arg2);
6732
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 Py_INCREF(Py_None); resultobj = Py_None;
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6746 double arg2 ;
6747 PyObject * obj0 = 0 ;
6748 PyObject * obj1 = 0 ;
6749 char *kwnames[] = {
6750 (char *) "self",(char *) "degrees", NULL
6751 };
6752
6753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6755 if (SWIG_arg_fail(1)) SWIG_fail;
6756 {
6757 arg2 = (double)(SWIG_As_double(obj1));
6758 if (SWIG_arg_fail(2)) SWIG_fail;
6759 }
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 (arg1)->SetVectorAngle(arg2);
6763
6764 wxPyEndAllowThreads(__tstate);
6765 if (PyErr_Occurred()) SWIG_fail;
6766 }
6767 Py_INCREF(Py_None); resultobj = Py_None;
6768 return resultobj;
6769 fail:
6770 return NULL;
6771 }
6772
6773
6774 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6775 PyObject *resultobj;
6776 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6777 wxPoint2D *arg2 = 0 ;
6778 double result;
6779 wxPoint2D temp2 ;
6780 PyObject * obj0 = 0 ;
6781 PyObject * obj1 = 0 ;
6782 char *kwnames[] = {
6783 (char *) "self",(char *) "pt", NULL
6784 };
6785
6786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6788 if (SWIG_arg_fail(1)) SWIG_fail;
6789 {
6790 arg2 = &temp2;
6791 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6792 }
6793 {
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6796
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 {
6801 resultobj = SWIG_From_double((double)(result));
6802 }
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj;
6811 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6812 wxPoint2D *arg2 = 0 ;
6813 double result;
6814 wxPoint2D temp2 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char *kwnames[] = {
6818 (char *) "self",(char *) "pt", NULL
6819 };
6820
6821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6823 if (SWIG_arg_fail(1)) SWIG_fail;
6824 {
6825 arg2 = &temp2;
6826 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6827 }
6828 {
6829 PyThreadState* __tstate = wxPyBeginAllowThreads();
6830 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6831
6832 wxPyEndAllowThreads(__tstate);
6833 if (PyErr_Occurred()) SWIG_fail;
6834 }
6835 {
6836 resultobj = SWIG_From_double((double)(result));
6837 }
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6845 PyObject *resultobj;
6846 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6847 wxPoint2D *arg2 = 0 ;
6848 double result;
6849 wxPoint2D temp2 ;
6850 PyObject * obj0 = 0 ;
6851 PyObject * obj1 = 0 ;
6852 char *kwnames[] = {
6853 (char *) "self",(char *) "vec", NULL
6854 };
6855
6856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6858 if (SWIG_arg_fail(1)) SWIG_fail;
6859 {
6860 arg2 = &temp2;
6861 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6862 }
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 {
6871 resultobj = SWIG_From_double((double)(result));
6872 }
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6880 PyObject *resultobj;
6881 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6882 wxPoint2D *arg2 = 0 ;
6883 double result;
6884 wxPoint2D temp2 ;
6885 PyObject * obj0 = 0 ;
6886 PyObject * obj1 = 0 ;
6887 char *kwnames[] = {
6888 (char *) "self",(char *) "vec", NULL
6889 };
6890
6891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6893 if (SWIG_arg_fail(1)) SWIG_fail;
6894 {
6895 arg2 = &temp2;
6896 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6897 }
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6901
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 {
6906 resultobj = SWIG_From_double((double)(result));
6907 }
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj;
6916 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6917 wxPoint2D result;
6918 PyObject * obj0 = 0 ;
6919 char *kwnames[] = {
6920 (char *) "self", NULL
6921 };
6922
6923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6925 if (SWIG_arg_fail(1)) SWIG_fail;
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = (arg1)->operator -();
6929
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 {
6934 wxPoint2D * resultptr;
6935 resultptr = new wxPoint2D((wxPoint2D &)(result));
6936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6937 }
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj;
6946 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6947 wxPoint2D *arg2 = 0 ;
6948 wxPoint2D *result;
6949 wxPoint2D temp2 ;
6950 PyObject * obj0 = 0 ;
6951 PyObject * obj1 = 0 ;
6952 char *kwnames[] = {
6953 (char *) "self",(char *) "pt", NULL
6954 };
6955
6956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6958 if (SWIG_arg_fail(1)) SWIG_fail;
6959 {
6960 arg2 = &temp2;
6961 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6962 }
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 {
6966 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6967 result = (wxPoint2D *) &_result_ref;
6968 }
6969
6970 wxPyEndAllowThreads(__tstate);
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6974 return resultobj;
6975 fail:
6976 return NULL;
6977 }
6978
6979
6980 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6981 PyObject *resultobj;
6982 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6983 wxPoint2D *arg2 = 0 ;
6984 wxPoint2D *result;
6985 wxPoint2D temp2 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char *kwnames[] = {
6989 (char *) "self",(char *) "pt", NULL
6990 };
6991
6992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6994 if (SWIG_arg_fail(1)) SWIG_fail;
6995 {
6996 arg2 = &temp2;
6997 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6998 }
6999 {
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 {
7002 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7003 result = (wxPoint2D *) &_result_ref;
7004 }
7005
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj;
7018 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7019 wxPoint2D *arg2 = 0 ;
7020 wxPoint2D *result;
7021 wxPoint2D temp2 ;
7022 PyObject * obj0 = 0 ;
7023 PyObject * obj1 = 0 ;
7024 char *kwnames[] = {
7025 (char *) "self",(char *) "pt", NULL
7026 };
7027
7028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7030 if (SWIG_arg_fail(1)) SWIG_fail;
7031 {
7032 arg2 = &temp2;
7033 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7034 }
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 {
7038 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7039 result = (wxPoint2D *) &_result_ref;
7040 }
7041
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7053 PyObject *resultobj;
7054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7055 wxPoint2D *arg2 = 0 ;
7056 wxPoint2D *result;
7057 wxPoint2D temp2 ;
7058 PyObject * obj0 = 0 ;
7059 PyObject * obj1 = 0 ;
7060 char *kwnames[] = {
7061 (char *) "self",(char *) "pt", NULL
7062 };
7063
7064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7066 if (SWIG_arg_fail(1)) SWIG_fail;
7067 {
7068 arg2 = &temp2;
7069 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7070 }
7071 {
7072 PyThreadState* __tstate = wxPyBeginAllowThreads();
7073 {
7074 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7075 result = (wxPoint2D *) &_result_ref;
7076 }
7077
7078 wxPyEndAllowThreads(__tstate);
7079 if (PyErr_Occurred()) SWIG_fail;
7080 }
7081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7082 return resultobj;
7083 fail:
7084 return NULL;
7085 }
7086
7087
7088 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7089 PyObject *resultobj;
7090 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7091 wxPoint2D *arg2 = 0 ;
7092 bool result;
7093 wxPoint2D temp2 ;
7094 PyObject * obj0 = 0 ;
7095 PyObject * obj1 = 0 ;
7096 char *kwnames[] = {
7097 (char *) "self",(char *) "pt", NULL
7098 };
7099
7100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7102 if (SWIG_arg_fail(1)) SWIG_fail;
7103 {
7104 arg2 = &temp2;
7105 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7106 }
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7110
7111 wxPyEndAllowThreads(__tstate);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 {
7115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7116 }
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj;
7125 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7126 wxPoint2D *arg2 = 0 ;
7127 bool result;
7128 wxPoint2D temp2 ;
7129 PyObject * obj0 = 0 ;
7130 PyObject * obj1 = 0 ;
7131 char *kwnames[] = {
7132 (char *) "self",(char *) "pt", NULL
7133 };
7134
7135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7137 if (SWIG_arg_fail(1)) SWIG_fail;
7138 {
7139 arg2 = &temp2;
7140 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7141 }
7142 {
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7145
7146 wxPyEndAllowThreads(__tstate);
7147 if (PyErr_Occurred()) SWIG_fail;
7148 }
7149 {
7150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7151 }
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj;
7160 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7161 double arg2 ;
7162 PyObject * obj0 = 0 ;
7163 PyObject * obj1 = 0 ;
7164 char *kwnames[] = {
7165 (char *) "self",(char *) "m_x", NULL
7166 };
7167
7168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7170 if (SWIG_arg_fail(1)) SWIG_fail;
7171 {
7172 arg2 = (double)(SWIG_As_double(obj1));
7173 if (SWIG_arg_fail(2)) SWIG_fail;
7174 }
7175 if (arg1) (arg1)->m_x = arg2;
7176
7177 Py_INCREF(Py_None); resultobj = Py_None;
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj;
7186 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7187 double result;
7188 PyObject * obj0 = 0 ;
7189 char *kwnames[] = {
7190 (char *) "self", NULL
7191 };
7192
7193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7195 if (SWIG_arg_fail(1)) SWIG_fail;
7196 result = (double) ((arg1)->m_x);
7197
7198 {
7199 resultobj = SWIG_From_double((double)(result));
7200 }
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7210 double arg2 ;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self",(char *) "m_y", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 {
7221 arg2 = (double)(SWIG_As_double(obj1));
7222 if (SWIG_arg_fail(2)) SWIG_fail;
7223 }
7224 if (arg1) (arg1)->m_y = arg2;
7225
7226 Py_INCREF(Py_None); resultobj = Py_None;
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj;
7235 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7236 double result;
7237 PyObject * obj0 = 0 ;
7238 char *kwnames[] = {
7239 (char *) "self", NULL
7240 };
7241
7242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7244 if (SWIG_arg_fail(1)) SWIG_fail;
7245 result = (double) ((arg1)->m_y);
7246
7247 {
7248 resultobj = SWIG_From_double((double)(result));
7249 }
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj;
7258 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7259 double arg2 = (double) 0 ;
7260 double arg3 = (double) 0 ;
7261 PyObject * obj0 = 0 ;
7262 PyObject * obj1 = 0 ;
7263 PyObject * obj2 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self",(char *) "x",(char *) "y", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 if (obj1) {
7272 {
7273 arg2 = (double)(SWIG_As_double(obj1));
7274 if (SWIG_arg_fail(2)) SWIG_fail;
7275 }
7276 }
7277 if (obj2) {
7278 {
7279 arg3 = (double)(SWIG_As_double(obj2));
7280 if (SWIG_arg_fail(3)) SWIG_fail;
7281 }
7282 }
7283 {
7284 PyThreadState* __tstate = wxPyBeginAllowThreads();
7285 wxPoint2D_Set(arg1,arg2,arg3);
7286
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 Py_INCREF(Py_None); resultobj = Py_None;
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj;
7299 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7300 PyObject *result;
7301 PyObject * obj0 = 0 ;
7302 char *kwnames[] = {
7303 (char *) "self", NULL
7304 };
7305
7306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7308 if (SWIG_arg_fail(1)) SWIG_fail;
7309 {
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 result = (PyObject *)wxPoint2D_Get(arg1);
7312
7313 wxPyEndAllowThreads(__tstate);
7314 if (PyErr_Occurred()) SWIG_fail;
7315 }
7316 resultobj = result;
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7324 PyObject *obj;
7325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7326 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7327 Py_INCREF(obj);
7328 return Py_BuildValue((char *)"");
7329 }
7330 static int _wrap_DefaultPosition_set(PyObject *) {
7331 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7332 return 1;
7333 }
7334
7335
7336 static PyObject *_wrap_DefaultPosition_get(void) {
7337 PyObject *pyobj;
7338
7339 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7340 return pyobj;
7341 }
7342
7343
7344 static int _wrap_DefaultSize_set(PyObject *) {
7345 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7346 return 1;
7347 }
7348
7349
7350 static PyObject *_wrap_DefaultSize_get(void) {
7351 PyObject *pyobj;
7352
7353 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7354 return pyobj;
7355 }
7356
7357
7358 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 PyObject *arg1 = (PyObject *) 0 ;
7361 wxPyInputStream *result;
7362 PyObject * obj0 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "p", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7368 arg1 = obj0;
7369 {
7370 PyThreadState* __tstate = wxPyBeginAllowThreads();
7371 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7372
7373 wxPyEndAllowThreads(__tstate);
7374 if (PyErr_Occurred()) SWIG_fail;
7375 }
7376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7377 return resultobj;
7378 fail:
7379 return NULL;
7380 }
7381
7382
7383 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7384 PyObject *resultobj;
7385 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7386 PyObject * obj0 = 0 ;
7387 char *kwnames[] = {
7388 (char *) "self", NULL
7389 };
7390
7391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7393 if (SWIG_arg_fail(1)) SWIG_fail;
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 delete arg1;
7397
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 Py_INCREF(Py_None); resultobj = Py_None;
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj;
7410 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7411 PyObject * obj0 = 0 ;
7412 char *kwnames[] = {
7413 (char *) "self", NULL
7414 };
7415
7416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7418 if (SWIG_arg_fail(1)) SWIG_fail;
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 (arg1)->close();
7422
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 Py_INCREF(Py_None); resultobj = Py_None;
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj;
7435 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7436 PyObject * obj0 = 0 ;
7437 char *kwnames[] = {
7438 (char *) "self", NULL
7439 };
7440
7441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7443 if (SWIG_arg_fail(1)) SWIG_fail;
7444 {
7445 PyThreadState* __tstate = wxPyBeginAllowThreads();
7446 (arg1)->flush();
7447
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 Py_INCREF(Py_None); resultobj = Py_None;
7452 return resultobj;
7453 fail:
7454 return NULL;
7455 }
7456
7457
7458 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7459 PyObject *resultobj;
7460 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7461 bool result;
7462 PyObject * obj0 = 0 ;
7463 char *kwnames[] = {
7464 (char *) "self", NULL
7465 };
7466
7467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7469 if (SWIG_arg_fail(1)) SWIG_fail;
7470 {
7471 PyThreadState* __tstate = wxPyBeginAllowThreads();
7472 result = (bool)(arg1)->eof();
7473
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 {
7478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7489 int arg2 = (int) -1 ;
7490 PyObject *result;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char *kwnames[] = {
7494 (char *) "self",(char *) "size", NULL
7495 };
7496
7497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7499 if (SWIG_arg_fail(1)) SWIG_fail;
7500 if (obj1) {
7501 {
7502 arg2 = (int)(SWIG_As_int(obj1));
7503 if (SWIG_arg_fail(2)) SWIG_fail;
7504 }
7505 }
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 result = (PyObject *)(arg1)->read(arg2);
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = result;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7523 int arg2 = (int) -1 ;
7524 PyObject *result;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char *kwnames[] = {
7528 (char *) "self",(char *) "size", NULL
7529 };
7530
7531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(1)) SWIG_fail;
7534 if (obj1) {
7535 {
7536 arg2 = (int)(SWIG_As_int(obj1));
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 }
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (PyObject *)(arg1)->readline(arg2);
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = result;
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj;
7556 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7557 int arg2 = (int) -1 ;
7558 PyObject *result;
7559 PyObject * obj0 = 0 ;
7560 PyObject * obj1 = 0 ;
7561 char *kwnames[] = {
7562 (char *) "self",(char *) "sizehint", NULL
7563 };
7564
7565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7567 if (SWIG_arg_fail(1)) SWIG_fail;
7568 if (obj1) {
7569 {
7570 arg2 = (int)(SWIG_As_int(obj1));
7571 if (SWIG_arg_fail(2)) SWIG_fail;
7572 }
7573 }
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 result = (PyObject *)(arg1)->readlines(arg2);
7577
7578 wxPyEndAllowThreads(__tstate);
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 resultobj = result;
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj;
7590 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7591 int arg2 ;
7592 int arg3 = (int) 0 ;
7593 PyObject * obj0 = 0 ;
7594 PyObject * obj1 = 0 ;
7595 PyObject * obj2 = 0 ;
7596 char *kwnames[] = {
7597 (char *) "self",(char *) "offset",(char *) "whence", NULL
7598 };
7599
7600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7602 if (SWIG_arg_fail(1)) SWIG_fail;
7603 {
7604 arg2 = (int)(SWIG_As_int(obj1));
7605 if (SWIG_arg_fail(2)) SWIG_fail;
7606 }
7607 if (obj2) {
7608 {
7609 arg3 = (int)(SWIG_As_int(obj2));
7610 if (SWIG_arg_fail(3)) SWIG_fail;
7611 }
7612 }
7613 {
7614 PyThreadState* __tstate = wxPyBeginAllowThreads();
7615 (arg1)->seek(arg2,arg3);
7616
7617 wxPyEndAllowThreads(__tstate);
7618 if (PyErr_Occurred()) SWIG_fail;
7619 }
7620 Py_INCREF(Py_None); resultobj = Py_None;
7621 return resultobj;
7622 fail:
7623 return NULL;
7624 }
7625
7626
7627 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7628 PyObject *resultobj;
7629 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7630 int result;
7631 PyObject * obj0 = 0 ;
7632 char *kwnames[] = {
7633 (char *) "self", NULL
7634 };
7635
7636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7638 if (SWIG_arg_fail(1)) SWIG_fail;
7639 {
7640 PyThreadState* __tstate = wxPyBeginAllowThreads();
7641 result = (int)(arg1)->tell();
7642
7643 wxPyEndAllowThreads(__tstate);
7644 if (PyErr_Occurred()) SWIG_fail;
7645 }
7646 {
7647 resultobj = SWIG_From_int((int)(result));
7648 }
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7656 PyObject *resultobj;
7657 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7658 char result;
7659 PyObject * obj0 = 0 ;
7660 char *kwnames[] = {
7661 (char *) "self", NULL
7662 };
7663
7664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(1)) SWIG_fail;
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 result = (char)(arg1)->Peek();
7670
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 {
7675 resultobj = SWIG_From_char((char)(result));
7676 }
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7684 PyObject *resultobj;
7685 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7686 char result;
7687 PyObject * obj0 = 0 ;
7688 char *kwnames[] = {
7689 (char *) "self", NULL
7690 };
7691
7692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7694 if (SWIG_arg_fail(1)) SWIG_fail;
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (char)(arg1)->GetC();
7698
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 {
7703 resultobj = SWIG_From_char((char)(result));
7704 }
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj;
7713 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7714 size_t result;
7715 PyObject * obj0 = 0 ;
7716 char *kwnames[] = {
7717 (char *) "self", NULL
7718 };
7719
7720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7722 if (SWIG_arg_fail(1)) SWIG_fail;
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 result = (size_t)(arg1)->LastRead();
7726
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 {
7731 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7732 }
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7740 PyObject *resultobj;
7741 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7742 bool result;
7743 PyObject * obj0 = 0 ;
7744 char *kwnames[] = {
7745 (char *) "self", NULL
7746 };
7747
7748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7750 if (SWIG_arg_fail(1)) SWIG_fail;
7751 {
7752 PyThreadState* __tstate = wxPyBeginAllowThreads();
7753 result = (bool)(arg1)->CanRead();
7754
7755 wxPyEndAllowThreads(__tstate);
7756 if (PyErr_Occurred()) SWIG_fail;
7757 }
7758 {
7759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7760 }
7761 return resultobj;
7762 fail:
7763 return NULL;
7764 }
7765
7766
7767 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7768 PyObject *resultobj;
7769 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7770 bool result;
7771 PyObject * obj0 = 0 ;
7772 char *kwnames[] = {
7773 (char *) "self", NULL
7774 };
7775
7776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7778 if (SWIG_arg_fail(1)) SWIG_fail;
7779 {
7780 PyThreadState* __tstate = wxPyBeginAllowThreads();
7781 result = (bool)(arg1)->Eof();
7782
7783 wxPyEndAllowThreads(__tstate);
7784 if (PyErr_Occurred()) SWIG_fail;
7785 }
7786 {
7787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7788 }
7789 return resultobj;
7790 fail:
7791 return NULL;
7792 }
7793
7794
7795 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7796 PyObject *resultobj;
7797 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7798 char arg2 ;
7799 bool result;
7800 PyObject * obj0 = 0 ;
7801 PyObject * obj1 = 0 ;
7802 char *kwnames[] = {
7803 (char *) "self",(char *) "c", NULL
7804 };
7805
7806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7808 if (SWIG_arg_fail(1)) SWIG_fail;
7809 {
7810 arg2 = (char)(SWIG_As_char(obj1));
7811 if (SWIG_arg_fail(2)) SWIG_fail;
7812 }
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (bool)(arg1)->Ungetch(arg2);
7816
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 {
7821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7822 }
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7830 PyObject *resultobj;
7831 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7832 long arg2 ;
7833 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7834 long result;
7835 PyObject * obj0 = 0 ;
7836 PyObject * obj1 = 0 ;
7837 PyObject * obj2 = 0 ;
7838 char *kwnames[] = {
7839 (char *) "self",(char *) "pos",(char *) "mode", NULL
7840 };
7841
7842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7844 if (SWIG_arg_fail(1)) SWIG_fail;
7845 {
7846 arg2 = (long)(SWIG_As_long(obj1));
7847 if (SWIG_arg_fail(2)) SWIG_fail;
7848 }
7849 if (obj2) {
7850 {
7851 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7852 if (SWIG_arg_fail(3)) SWIG_fail;
7853 }
7854 }
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 {
7863 resultobj = SWIG_From_long((long)(result));
7864 }
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7872 PyObject *resultobj;
7873 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7874 long result;
7875 PyObject * obj0 = 0 ;
7876 char *kwnames[] = {
7877 (char *) "self", NULL
7878 };
7879
7880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7882 if (SWIG_arg_fail(1)) SWIG_fail;
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 result = (long)(arg1)->TellI();
7886
7887 wxPyEndAllowThreads(__tstate);
7888 if (PyErr_Occurred()) SWIG_fail;
7889 }
7890 {
7891 resultobj = SWIG_From_long((long)(result));
7892 }
7893 return resultobj;
7894 fail:
7895 return NULL;
7896 }
7897
7898
7899 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7900 PyObject *obj;
7901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7902 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7903 Py_INCREF(obj);
7904 return Py_BuildValue((char *)"");
7905 }
7906 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7907 PyObject *resultobj;
7908 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7909 PyObject *arg2 = (PyObject *) 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 char *kwnames[] = {
7913 (char *) "self",(char *) "obj", NULL
7914 };
7915
7916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7918 if (SWIG_arg_fail(1)) SWIG_fail;
7919 arg2 = obj1;
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 wxOutputStream_write(arg1,arg2);
7923
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 Py_INCREF(Py_None); resultobj = Py_None;
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7935 PyObject *obj;
7936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7937 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7938 Py_INCREF(obj);
7939 return Py_BuildValue((char *)"");
7940 }
7941 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj;
7943 wxInputStream *arg1 = (wxInputStream *) 0 ;
7944 wxString *arg2 = 0 ;
7945 wxString *arg3 = 0 ;
7946 wxString *arg4 = 0 ;
7947 wxDateTime arg5 ;
7948 wxFSFile *result;
7949 wxPyInputStream *temp1 ;
7950 bool temp2 = false ;
7951 bool temp3 = false ;
7952 bool temp4 = false ;
7953 PyObject * obj0 = 0 ;
7954 PyObject * obj1 = 0 ;
7955 PyObject * obj2 = 0 ;
7956 PyObject * obj3 = 0 ;
7957 PyObject * obj4 = 0 ;
7958 char *kwnames[] = {
7959 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7960 };
7961
7962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7963 {
7964 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7965 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7966 } else {
7967 PyErr_Clear(); // clear the failure of the wxPyConvert above
7968 arg1 = wxPyCBInputStream_create(obj0, true);
7969 if (arg1 == NULL) {
7970 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7971 SWIG_fail;
7972 }
7973 }
7974 }
7975 {
7976 arg2 = wxString_in_helper(obj1);
7977 if (arg2 == NULL) SWIG_fail;
7978 temp2 = true;
7979 }
7980 {
7981 arg3 = wxString_in_helper(obj2);
7982 if (arg3 == NULL) SWIG_fail;
7983 temp3 = true;
7984 }
7985 {
7986 arg4 = wxString_in_helper(obj3);
7987 if (arg4 == NULL) SWIG_fail;
7988 temp4 = true;
7989 }
7990 {
7991 wxDateTime * argp;
7992 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7993 if (SWIG_arg_fail(5)) SWIG_fail;
7994 if (argp == NULL) {
7995 SWIG_null_ref("wxDateTime");
7996 }
7997 if (SWIG_arg_fail(5)) SWIG_fail;
7998 arg5 = *argp;
7999 }
8000 {
8001 PyThreadState* __tstate = wxPyBeginAllowThreads();
8002 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8003
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 {
8008 resultobj = wxPyMake_wxObject(result, 1);
8009 }
8010 {
8011 if (temp2)
8012 delete arg2;
8013 }
8014 {
8015 if (temp3)
8016 delete arg3;
8017 }
8018 {
8019 if (temp4)
8020 delete arg4;
8021 }
8022 return resultobj;
8023 fail:
8024 {
8025 if (temp2)
8026 delete arg2;
8027 }
8028 {
8029 if (temp3)
8030 delete arg3;
8031 }
8032 {
8033 if (temp4)
8034 delete arg4;
8035 }
8036 return NULL;
8037 }
8038
8039
8040 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8041 PyObject *resultobj;
8042 wxFSFile *arg1 = (wxFSFile *) 0 ;
8043 PyObject * obj0 = 0 ;
8044 char *kwnames[] = {
8045 (char *) "self", NULL
8046 };
8047
8048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(1)) SWIG_fail;
8051 {
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 delete arg1;
8054
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 Py_INCREF(Py_None); resultobj = Py_None;
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8066 PyObject *resultobj;
8067 wxFSFile *arg1 = (wxFSFile *) 0 ;
8068 wxInputStream *result;
8069 PyObject * obj0 = 0 ;
8070 char *kwnames[] = {
8071 (char *) "self", NULL
8072 };
8073
8074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8076 if (SWIG_arg_fail(1)) SWIG_fail;
8077 {
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 result = (wxInputStream *)(arg1)->GetStream();
8080
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 {
8085 wxPyInputStream * _ptr = NULL;
8086
8087 if (result) {
8088 _ptr = new wxPyInputStream(result);
8089 }
8090 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8091 }
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8099 PyObject *resultobj;
8100 wxFSFile *arg1 = (wxFSFile *) 0 ;
8101 wxString *result;
8102 PyObject * obj0 = 0 ;
8103 char *kwnames[] = {
8104 (char *) "self", NULL
8105 };
8106
8107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8109 if (SWIG_arg_fail(1)) SWIG_fail;
8110 {
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 {
8113 wxString const &_result_ref = (arg1)->GetMimeType();
8114 result = (wxString *) &_result_ref;
8115 }
8116
8117 wxPyEndAllowThreads(__tstate);
8118 if (PyErr_Occurred()) SWIG_fail;
8119 }
8120 {
8121 #if wxUSE_UNICODE
8122 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8123 #else
8124 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8125 #endif
8126 }
8127 return resultobj;
8128 fail:
8129 return NULL;
8130 }
8131
8132
8133 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8134 PyObject *resultobj;
8135 wxFSFile *arg1 = (wxFSFile *) 0 ;
8136 wxString *result;
8137 PyObject * obj0 = 0 ;
8138 char *kwnames[] = {
8139 (char *) "self", NULL
8140 };
8141
8142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8144 if (SWIG_arg_fail(1)) SWIG_fail;
8145 {
8146 PyThreadState* __tstate = wxPyBeginAllowThreads();
8147 {
8148 wxString const &_result_ref = (arg1)->GetLocation();
8149 result = (wxString *) &_result_ref;
8150 }
8151
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 {
8156 #if wxUSE_UNICODE
8157 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8158 #else
8159 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8160 #endif
8161 }
8162 return resultobj;
8163 fail:
8164 return NULL;
8165 }
8166
8167
8168 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8169 PyObject *resultobj;
8170 wxFSFile *arg1 = (wxFSFile *) 0 ;
8171 wxString *result;
8172 PyObject * obj0 = 0 ;
8173 char *kwnames[] = {
8174 (char *) "self", NULL
8175 };
8176
8177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8179 if (SWIG_arg_fail(1)) SWIG_fail;
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 {
8183 wxString const &_result_ref = (arg1)->GetAnchor();
8184 result = (wxString *) &_result_ref;
8185 }
8186
8187 wxPyEndAllowThreads(__tstate);
8188 if (PyErr_Occurred()) SWIG_fail;
8189 }
8190 {
8191 #if wxUSE_UNICODE
8192 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8193 #else
8194 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8195 #endif
8196 }
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj;
8205 wxFSFile *arg1 = (wxFSFile *) 0 ;
8206 wxDateTime result;
8207 PyObject * obj0 = 0 ;
8208 char *kwnames[] = {
8209 (char *) "self", NULL
8210 };
8211
8212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8214 if (SWIG_arg_fail(1)) SWIG_fail;
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (arg1)->GetModificationTime();
8218
8219 wxPyEndAllowThreads(__tstate);
8220 if (PyErr_Occurred()) SWIG_fail;
8221 }
8222 {
8223 wxDateTime * resultptr;
8224 resultptr = new wxDateTime((wxDateTime &)(result));
8225 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8226 }
8227 return resultobj;
8228 fail:
8229 return NULL;
8230 }
8231
8232
8233 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8234 PyObject *obj;
8235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8236 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8237 Py_INCREF(obj);
8238 return Py_BuildValue((char *)"");
8239 }
8240 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8241 PyObject *obj;
8242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8243 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8244 Py_INCREF(obj);
8245 return Py_BuildValue((char *)"");
8246 }
8247 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8248 PyObject *resultobj;
8249 wxPyFileSystemHandler *result;
8250 char *kwnames[] = {
8251 NULL
8252 };
8253
8254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8263 return resultobj;
8264 fail:
8265 return NULL;
8266 }
8267
8268
8269 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8270 PyObject *resultobj;
8271 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8272 PyObject *arg2 = (PyObject *) 0 ;
8273 PyObject *arg3 = (PyObject *) 0 ;
8274 PyObject * obj0 = 0 ;
8275 PyObject * obj1 = 0 ;
8276 PyObject * obj2 = 0 ;
8277 char *kwnames[] = {
8278 (char *) "self",(char *) "self",(char *) "_class", NULL
8279 };
8280
8281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8283 if (SWIG_arg_fail(1)) SWIG_fail;
8284 arg2 = obj1;
8285 arg3 = obj2;
8286 {
8287 PyThreadState* __tstate = wxPyBeginAllowThreads();
8288 (arg1)->_setCallbackInfo(arg2,arg3);
8289
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 Py_INCREF(Py_None); resultobj = Py_None;
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj;
8302 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8303 wxString *arg2 = 0 ;
8304 bool result;
8305 bool temp2 = false ;
8306 PyObject * obj0 = 0 ;
8307 PyObject * obj1 = 0 ;
8308 char *kwnames[] = {
8309 (char *) "self",(char *) "location", NULL
8310 };
8311
8312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8314 if (SWIG_arg_fail(1)) SWIG_fail;
8315 {
8316 arg2 = wxString_in_helper(obj1);
8317 if (arg2 == NULL) SWIG_fail;
8318 temp2 = true;
8319 }
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8323
8324 wxPyEndAllowThreads(__tstate);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 {
8328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8329 }
8330 {
8331 if (temp2)
8332 delete arg2;
8333 }
8334 return resultobj;
8335 fail:
8336 {
8337 if (temp2)
8338 delete arg2;
8339 }
8340 return NULL;
8341 }
8342
8343
8344 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj;
8346 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8347 wxFileSystem *arg2 = 0 ;
8348 wxString *arg3 = 0 ;
8349 wxFSFile *result;
8350 bool temp3 = false ;
8351 PyObject * obj0 = 0 ;
8352 PyObject * obj1 = 0 ;
8353 PyObject * obj2 = 0 ;
8354 char *kwnames[] = {
8355 (char *) "self",(char *) "fs",(char *) "location", NULL
8356 };
8357
8358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8360 if (SWIG_arg_fail(1)) SWIG_fail;
8361 {
8362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8363 if (SWIG_arg_fail(2)) SWIG_fail;
8364 if (arg2 == NULL) {
8365 SWIG_null_ref("wxFileSystem");
8366 }
8367 if (SWIG_arg_fail(2)) SWIG_fail;
8368 }
8369 {
8370 arg3 = wxString_in_helper(obj2);
8371 if (arg3 == NULL) SWIG_fail;
8372 temp3 = true;
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8377
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 {
8382 resultobj = wxPyMake_wxObject(result, 1);
8383 }
8384 {
8385 if (temp3)
8386 delete arg3;
8387 }
8388 return resultobj;
8389 fail:
8390 {
8391 if (temp3)
8392 delete arg3;
8393 }
8394 return NULL;
8395 }
8396
8397
8398 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj;
8400 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8401 wxString *arg2 = 0 ;
8402 int arg3 = (int) 0 ;
8403 wxString result;
8404 bool temp2 = false ;
8405 PyObject * obj0 = 0 ;
8406 PyObject * obj1 = 0 ;
8407 PyObject * obj2 = 0 ;
8408 char *kwnames[] = {
8409 (char *) "self",(char *) "spec",(char *) "flags", NULL
8410 };
8411
8412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8414 if (SWIG_arg_fail(1)) SWIG_fail;
8415 {
8416 arg2 = wxString_in_helper(obj1);
8417 if (arg2 == NULL) SWIG_fail;
8418 temp2 = true;
8419 }
8420 if (obj2) {
8421 {
8422 arg3 = (int)(SWIG_As_int(obj2));
8423 if (SWIG_arg_fail(3)) SWIG_fail;
8424 }
8425 }
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8429
8430 wxPyEndAllowThreads(__tstate);
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 {
8434 #if wxUSE_UNICODE
8435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8436 #else
8437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8438 #endif
8439 }
8440 {
8441 if (temp2)
8442 delete arg2;
8443 }
8444 return resultobj;
8445 fail:
8446 {
8447 if (temp2)
8448 delete arg2;
8449 }
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj;
8456 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8457 wxString result;
8458 PyObject * obj0 = 0 ;
8459 char *kwnames[] = {
8460 (char *) "self", NULL
8461 };
8462
8463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8465 if (SWIG_arg_fail(1)) SWIG_fail;
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 result = (arg1)->FindNext();
8469
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 {
8474 #if wxUSE_UNICODE
8475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8476 #else
8477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8478 #endif
8479 }
8480 return resultobj;
8481 fail:
8482 return NULL;
8483 }
8484
8485
8486 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8487 PyObject *resultobj;
8488 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8489 wxString *arg2 = 0 ;
8490 wxString result;
8491 bool temp2 = false ;
8492 PyObject * obj0 = 0 ;
8493 PyObject * obj1 = 0 ;
8494 char *kwnames[] = {
8495 (char *) "self",(char *) "location", NULL
8496 };
8497
8498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8500 if (SWIG_arg_fail(1)) SWIG_fail;
8501 {
8502 arg2 = wxString_in_helper(obj1);
8503 if (arg2 == NULL) SWIG_fail;
8504 temp2 = true;
8505 }
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 result = (arg1)->GetProtocol((wxString const &)*arg2);
8509
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 {
8514 #if wxUSE_UNICODE
8515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8516 #else
8517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8518 #endif
8519 }
8520 {
8521 if (temp2)
8522 delete arg2;
8523 }
8524 return resultobj;
8525 fail:
8526 {
8527 if (temp2)
8528 delete arg2;
8529 }
8530 return NULL;
8531 }
8532
8533
8534 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj;
8536 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8537 wxString *arg2 = 0 ;
8538 wxString result;
8539 bool temp2 = false ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 char *kwnames[] = {
8543 (char *) "self",(char *) "location", NULL
8544 };
8545
8546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8548 if (SWIG_arg_fail(1)) SWIG_fail;
8549 {
8550 arg2 = wxString_in_helper(obj1);
8551 if (arg2 == NULL) SWIG_fail;
8552 temp2 = true;
8553 }
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8557
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 #if wxUSE_UNICODE
8563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8564 #else
8565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8566 #endif
8567 }
8568 {
8569 if (temp2)
8570 delete arg2;
8571 }
8572 return resultobj;
8573 fail:
8574 {
8575 if (temp2)
8576 delete arg2;
8577 }
8578 return NULL;
8579 }
8580
8581
8582 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj;
8584 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8585 wxString *arg2 = 0 ;
8586 wxString result;
8587 bool temp2 = false ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 char *kwnames[] = {
8591 (char *) "self",(char *) "location", NULL
8592 };
8593
8594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8596 if (SWIG_arg_fail(1)) SWIG_fail;
8597 {
8598 arg2 = wxString_in_helper(obj1);
8599 if (arg2 == NULL) SWIG_fail;
8600 temp2 = true;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 result = (arg1)->GetAnchor((wxString const &)*arg2);
8605
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 {
8610 #if wxUSE_UNICODE
8611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8612 #else
8613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8614 #endif
8615 }
8616 {
8617 if (temp2)
8618 delete arg2;
8619 }
8620 return resultobj;
8621 fail:
8622 {
8623 if (temp2)
8624 delete arg2;
8625 }
8626 return NULL;
8627 }
8628
8629
8630 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8631 PyObject *resultobj;
8632 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8633 wxString *arg2 = 0 ;
8634 wxString result;
8635 bool temp2 = false ;
8636 PyObject * obj0 = 0 ;
8637 PyObject * obj1 = 0 ;
8638 char *kwnames[] = {
8639 (char *) "self",(char *) "location", NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8644 if (SWIG_arg_fail(1)) SWIG_fail;
8645 {
8646 arg2 = wxString_in_helper(obj1);
8647 if (arg2 == NULL) SWIG_fail;
8648 temp2 = true;
8649 }
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 {
8658 #if wxUSE_UNICODE
8659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8660 #else
8661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8662 #endif
8663 }
8664 {
8665 if (temp2)
8666 delete arg2;
8667 }
8668 return resultobj;
8669 fail:
8670 {
8671 if (temp2)
8672 delete arg2;
8673 }
8674 return NULL;
8675 }
8676
8677
8678 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj;
8680 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8681 wxString *arg2 = 0 ;
8682 wxString result;
8683 bool temp2 = false ;
8684 PyObject * obj0 = 0 ;
8685 PyObject * obj1 = 0 ;
8686 char *kwnames[] = {
8687 (char *) "self",(char *) "location", NULL
8688 };
8689
8690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8692 if (SWIG_arg_fail(1)) SWIG_fail;
8693 {
8694 arg2 = wxString_in_helper(obj1);
8695 if (arg2 == NULL) SWIG_fail;
8696 temp2 = true;
8697 }
8698 {
8699 PyThreadState* __tstate = wxPyBeginAllowThreads();
8700 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8701
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 {
8706 #if wxUSE_UNICODE
8707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8708 #else
8709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8710 #endif
8711 }
8712 {
8713 if (temp2)
8714 delete arg2;
8715 }
8716 return resultobj;
8717 fail:
8718 {
8719 if (temp2)
8720 delete arg2;
8721 }
8722 return NULL;
8723 }
8724
8725
8726 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8727 PyObject *obj;
8728 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8729 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8730 Py_INCREF(obj);
8731 return Py_BuildValue((char *)"");
8732 }
8733 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj;
8735 wxFileSystem *result;
8736 char *kwnames[] = {
8737 NULL
8738 };
8739
8740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8741 {
8742 PyThreadState* __tstate = wxPyBeginAllowThreads();
8743 result = (wxFileSystem *)new wxFileSystem();
8744
8745 wxPyEndAllowThreads(__tstate);
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 {
8749 resultobj = wxPyMake_wxObject(result, 1);
8750 }
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8758 PyObject *resultobj;
8759 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8760 PyObject * obj0 = 0 ;
8761 char *kwnames[] = {
8762 (char *) "self", NULL
8763 };
8764
8765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8767 if (SWIG_arg_fail(1)) SWIG_fail;
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 delete arg1;
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 Py_INCREF(Py_None); resultobj = Py_None;
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8785 wxString *arg2 = 0 ;
8786 bool arg3 = (bool) false ;
8787 bool temp2 = false ;
8788 PyObject * obj0 = 0 ;
8789 PyObject * obj1 = 0 ;
8790 PyObject * obj2 = 0 ;
8791 char *kwnames[] = {
8792 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8793 };
8794
8795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8797 if (SWIG_arg_fail(1)) SWIG_fail;
8798 {
8799 arg2 = wxString_in_helper(obj1);
8800 if (arg2 == NULL) SWIG_fail;
8801 temp2 = true;
8802 }
8803 if (obj2) {
8804 {
8805 arg3 = (bool)(SWIG_As_bool(obj2));
8806 if (SWIG_arg_fail(3)) SWIG_fail;
8807 }
8808 }
8809 {
8810 PyThreadState* __tstate = wxPyBeginAllowThreads();
8811 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8812
8813 wxPyEndAllowThreads(__tstate);
8814 if (PyErr_Occurred()) SWIG_fail;
8815 }
8816 Py_INCREF(Py_None); resultobj = Py_None;
8817 {
8818 if (temp2)
8819 delete arg2;
8820 }
8821 return resultobj;
8822 fail:
8823 {
8824 if (temp2)
8825 delete arg2;
8826 }
8827 return NULL;
8828 }
8829
8830
8831 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj;
8833 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8834 wxString result;
8835 PyObject * obj0 = 0 ;
8836 char *kwnames[] = {
8837 (char *) "self", NULL
8838 };
8839
8840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8842 if (SWIG_arg_fail(1)) SWIG_fail;
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 result = (arg1)->GetPath();
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 {
8851 #if wxUSE_UNICODE
8852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8853 #else
8854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8855 #endif
8856 }
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8864 PyObject *resultobj;
8865 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8866 wxString *arg2 = 0 ;
8867 wxFSFile *result;
8868 bool temp2 = false ;
8869 PyObject * obj0 = 0 ;
8870 PyObject * obj1 = 0 ;
8871 char *kwnames[] = {
8872 (char *) "self",(char *) "location", NULL
8873 };
8874
8875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8877 if (SWIG_arg_fail(1)) SWIG_fail;
8878 {
8879 arg2 = wxString_in_helper(obj1);
8880 if (arg2 == NULL) SWIG_fail;
8881 temp2 = true;
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 {
8891 resultobj = wxPyMake_wxObject(result, 1);
8892 }
8893 {
8894 if (temp2)
8895 delete arg2;
8896 }
8897 return resultobj;
8898 fail:
8899 {
8900 if (temp2)
8901 delete arg2;
8902 }
8903 return NULL;
8904 }
8905
8906
8907 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj;
8909 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8910 wxString *arg2 = 0 ;
8911 int arg3 = (int) 0 ;
8912 wxString result;
8913 bool temp2 = false ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 PyObject * obj2 = 0 ;
8917 char *kwnames[] = {
8918 (char *) "self",(char *) "spec",(char *) "flags", NULL
8919 };
8920
8921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8923 if (SWIG_arg_fail(1)) SWIG_fail;
8924 {
8925 arg2 = wxString_in_helper(obj1);
8926 if (arg2 == NULL) SWIG_fail;
8927 temp2 = true;
8928 }
8929 if (obj2) {
8930 {
8931 arg3 = (int)(SWIG_As_int(obj2));
8932 if (SWIG_arg_fail(3)) SWIG_fail;
8933 }
8934 }
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 {
8943 #if wxUSE_UNICODE
8944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8945 #else
8946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8947 #endif
8948 }
8949 {
8950 if (temp2)
8951 delete arg2;
8952 }
8953 return resultobj;
8954 fail:
8955 {
8956 if (temp2)
8957 delete arg2;
8958 }
8959 return NULL;
8960 }
8961
8962
8963 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj;
8965 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8966 wxString result;
8967 PyObject * obj0 = 0 ;
8968 char *kwnames[] = {
8969 (char *) "self", NULL
8970 };
8971
8972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8974 if (SWIG_arg_fail(1)) SWIG_fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 result = (arg1)->FindNext();
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 {
8983 #if wxUSE_UNICODE
8984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8985 #else
8986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8987 #endif
8988 }
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8996 PyObject *resultobj;
8997 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8998 PyObject * obj0 = 0 ;
8999 char *kwnames[] = {
9000 (char *) "handler", NULL
9001 };
9002
9003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9005 if (SWIG_arg_fail(1)) SWIG_fail;
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 wxFileSystem::AddHandler(arg1);
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 Py_INCREF(Py_None); resultobj = Py_None;
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj;
9022 char *kwnames[] = {
9023 NULL
9024 };
9025
9026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 wxFileSystem::CleanUpHandlers();
9030
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 Py_INCREF(Py_None); resultobj = Py_None;
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 wxString *arg1 = 0 ;
9044 wxString result;
9045 bool temp1 = false ;
9046 PyObject * obj0 = 0 ;
9047 char *kwnames[] = {
9048 (char *) "filename", NULL
9049 };
9050
9051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9052 {
9053 arg1 = wxString_in_helper(obj0);
9054 if (arg1 == NULL) SWIG_fail;
9055 temp1 = true;
9056 }
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9060
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 {
9065 #if wxUSE_UNICODE
9066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9067 #else
9068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9069 #endif
9070 }
9071 {
9072 if (temp1)
9073 delete arg1;
9074 }
9075 return resultobj;
9076 fail:
9077 {
9078 if (temp1)
9079 delete arg1;
9080 }
9081 return NULL;
9082 }
9083
9084
9085 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9086 PyObject *resultobj;
9087 wxString *arg1 = 0 ;
9088 wxString result;
9089 bool temp1 = false ;
9090 PyObject * obj0 = 0 ;
9091 char *kwnames[] = {
9092 (char *) "url", NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9096 {
9097 arg1 = wxString_in_helper(obj0);
9098 if (arg1 == NULL) SWIG_fail;
9099 temp1 = true;
9100 }
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = FileSystem_URLToFileName((wxString const &)*arg1);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 {
9109 #if wxUSE_UNICODE
9110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9111 #else
9112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9113 #endif
9114 }
9115 {
9116 if (temp1)
9117 delete arg1;
9118 }
9119 return resultobj;
9120 fail:
9121 {
9122 if (temp1)
9123 delete arg1;
9124 }
9125 return NULL;
9126 }
9127
9128
9129 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9130 PyObject *obj;
9131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9132 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9133 Py_INCREF(obj);
9134 return Py_BuildValue((char *)"");
9135 }
9136 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9137 PyObject *resultobj;
9138 wxInternetFSHandler *result;
9139 char *kwnames[] = {
9140 NULL
9141 };
9142
9143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9147
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj;
9160 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9161 wxString *arg2 = 0 ;
9162 bool result;
9163 bool temp2 = false ;
9164 PyObject * obj0 = 0 ;
9165 PyObject * obj1 = 0 ;
9166 char *kwnames[] = {
9167 (char *) "self",(char *) "location", NULL
9168 };
9169
9170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9172 if (SWIG_arg_fail(1)) SWIG_fail;
9173 {
9174 arg2 = wxString_in_helper(obj1);
9175 if (arg2 == NULL) SWIG_fail;
9176 temp2 = true;
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 {
9186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9187 }
9188 {
9189 if (temp2)
9190 delete arg2;
9191 }
9192 return resultobj;
9193 fail:
9194 {
9195 if (temp2)
9196 delete arg2;
9197 }
9198 return NULL;
9199 }
9200
9201
9202 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9203 PyObject *resultobj;
9204 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9205 wxFileSystem *arg2 = 0 ;
9206 wxString *arg3 = 0 ;
9207 wxFSFile *result;
9208 bool temp3 = false ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 PyObject * obj2 = 0 ;
9212 char *kwnames[] = {
9213 (char *) "self",(char *) "fs",(char *) "location", NULL
9214 };
9215
9216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9218 if (SWIG_arg_fail(1)) SWIG_fail;
9219 {
9220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9221 if (SWIG_arg_fail(2)) SWIG_fail;
9222 if (arg2 == NULL) {
9223 SWIG_null_ref("wxFileSystem");
9224 }
9225 if (SWIG_arg_fail(2)) SWIG_fail;
9226 }
9227 {
9228 arg3 = wxString_in_helper(obj2);
9229 if (arg3 == NULL) SWIG_fail;
9230 temp3 = true;
9231 }
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 {
9240 resultobj = wxPyMake_wxObject(result, 1);
9241 }
9242 {
9243 if (temp3)
9244 delete arg3;
9245 }
9246 return resultobj;
9247 fail:
9248 {
9249 if (temp3)
9250 delete arg3;
9251 }
9252 return NULL;
9253 }
9254
9255
9256 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9257 PyObject *obj;
9258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9259 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9260 Py_INCREF(obj);
9261 return Py_BuildValue((char *)"");
9262 }
9263 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9264 PyObject *resultobj;
9265 wxZipFSHandler *result;
9266 char *kwnames[] = {
9267 NULL
9268 };
9269
9270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxZipFSHandler *)new wxZipFSHandler();
9274
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj;
9287 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9288 wxString *arg2 = 0 ;
9289 bool result;
9290 bool temp2 = false ;
9291 PyObject * obj0 = 0 ;
9292 PyObject * obj1 = 0 ;
9293 char *kwnames[] = {
9294 (char *) "self",(char *) "location", NULL
9295 };
9296
9297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9299 if (SWIG_arg_fail(1)) SWIG_fail;
9300 {
9301 arg2 = wxString_in_helper(obj1);
9302 if (arg2 == NULL) SWIG_fail;
9303 temp2 = true;
9304 }
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 {
9313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9314 }
9315 {
9316 if (temp2)
9317 delete arg2;
9318 }
9319 return resultobj;
9320 fail:
9321 {
9322 if (temp2)
9323 delete arg2;
9324 }
9325 return NULL;
9326 }
9327
9328
9329 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9330 PyObject *resultobj;
9331 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9332 wxFileSystem *arg2 = 0 ;
9333 wxString *arg3 = 0 ;
9334 wxFSFile *result;
9335 bool temp3 = false ;
9336 PyObject * obj0 = 0 ;
9337 PyObject * obj1 = 0 ;
9338 PyObject * obj2 = 0 ;
9339 char *kwnames[] = {
9340 (char *) "self",(char *) "fs",(char *) "location", NULL
9341 };
9342
9343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9345 if (SWIG_arg_fail(1)) SWIG_fail;
9346 {
9347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9348 if (SWIG_arg_fail(2)) SWIG_fail;
9349 if (arg2 == NULL) {
9350 SWIG_null_ref("wxFileSystem");
9351 }
9352 if (SWIG_arg_fail(2)) SWIG_fail;
9353 }
9354 {
9355 arg3 = wxString_in_helper(obj2);
9356 if (arg3 == NULL) SWIG_fail;
9357 temp3 = true;
9358 }
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9362
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 {
9367 resultobj = wxPyMake_wxObject(result, 1);
9368 }
9369 {
9370 if (temp3)
9371 delete arg3;
9372 }
9373 return resultobj;
9374 fail:
9375 {
9376 if (temp3)
9377 delete arg3;
9378 }
9379 return NULL;
9380 }
9381
9382
9383 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9384 PyObject *resultobj;
9385 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9386 wxString *arg2 = 0 ;
9387 int arg3 = (int) 0 ;
9388 wxString result;
9389 bool temp2 = false ;
9390 PyObject * obj0 = 0 ;
9391 PyObject * obj1 = 0 ;
9392 PyObject * obj2 = 0 ;
9393 char *kwnames[] = {
9394 (char *) "self",(char *) "spec",(char *) "flags", NULL
9395 };
9396
9397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9399 if (SWIG_arg_fail(1)) SWIG_fail;
9400 {
9401 arg2 = wxString_in_helper(obj1);
9402 if (arg2 == NULL) SWIG_fail;
9403 temp2 = true;
9404 }
9405 if (obj2) {
9406 {
9407 arg3 = (int)(SWIG_As_int(obj2));
9408 if (SWIG_arg_fail(3)) SWIG_fail;
9409 }
9410 }
9411 {
9412 PyThreadState* __tstate = wxPyBeginAllowThreads();
9413 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9414
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 {
9419 #if wxUSE_UNICODE
9420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9421 #else
9422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9423 #endif
9424 }
9425 {
9426 if (temp2)
9427 delete arg2;
9428 }
9429 return resultobj;
9430 fail:
9431 {
9432 if (temp2)
9433 delete arg2;
9434 }
9435 return NULL;
9436 }
9437
9438
9439 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj;
9441 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9442 wxString result;
9443 PyObject * obj0 = 0 ;
9444 char *kwnames[] = {
9445 (char *) "self", NULL
9446 };
9447
9448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9450 if (SWIG_arg_fail(1)) SWIG_fail;
9451 {
9452 PyThreadState* __tstate = wxPyBeginAllowThreads();
9453 result = (arg1)->FindNext();
9454
9455 wxPyEndAllowThreads(__tstate);
9456 if (PyErr_Occurred()) SWIG_fail;
9457 }
9458 {
9459 #if wxUSE_UNICODE
9460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9461 #else
9462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9463 #endif
9464 }
9465 return resultobj;
9466 fail:
9467 return NULL;
9468 }
9469
9470
9471 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9472 PyObject *obj;
9473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9474 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9475 Py_INCREF(obj);
9476 return Py_BuildValue((char *)"");
9477 }
9478 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9479 PyObject *resultobj;
9480 wxString *arg1 = 0 ;
9481 wxImage *arg2 = 0 ;
9482 long arg3 ;
9483 bool temp1 = false ;
9484 PyObject * obj0 = 0 ;
9485 PyObject * obj1 = 0 ;
9486 PyObject * obj2 = 0 ;
9487 char *kwnames[] = {
9488 (char *) "filename",(char *) "image",(char *) "type", NULL
9489 };
9490
9491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9492 {
9493 arg1 = wxString_in_helper(obj0);
9494 if (arg1 == NULL) SWIG_fail;
9495 temp1 = true;
9496 }
9497 {
9498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9499 if (SWIG_arg_fail(2)) SWIG_fail;
9500 if (arg2 == NULL) {
9501 SWIG_null_ref("wxImage");
9502 }
9503 if (SWIG_arg_fail(2)) SWIG_fail;
9504 }
9505 {
9506 arg3 = (long)(SWIG_As_long(obj2));
9507 if (SWIG_arg_fail(3)) SWIG_fail;
9508 }
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9512
9513 wxPyEndAllowThreads(__tstate);
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 Py_INCREF(Py_None); resultobj = Py_None;
9517 {
9518 if (temp1)
9519 delete arg1;
9520 }
9521 return resultobj;
9522 fail:
9523 {
9524 if (temp1)
9525 delete arg1;
9526 }
9527 return NULL;
9528 }
9529
9530
9531 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9532 PyObject *resultobj;
9533 wxString *arg1 = 0 ;
9534 wxBitmap *arg2 = 0 ;
9535 long arg3 ;
9536 bool temp1 = false ;
9537 PyObject * obj0 = 0 ;
9538 PyObject * obj1 = 0 ;
9539 PyObject * obj2 = 0 ;
9540 char *kwnames[] = {
9541 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9542 };
9543
9544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9545 {
9546 arg1 = wxString_in_helper(obj0);
9547 if (arg1 == NULL) SWIG_fail;
9548 temp1 = true;
9549 }
9550 {
9551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9552 if (SWIG_arg_fail(2)) SWIG_fail;
9553 if (arg2 == NULL) {
9554 SWIG_null_ref("wxBitmap");
9555 }
9556 if (SWIG_arg_fail(2)) SWIG_fail;
9557 }
9558 {
9559 arg3 = (long)(SWIG_As_long(obj2));
9560 if (SWIG_arg_fail(3)) SWIG_fail;
9561 }
9562 {
9563 PyThreadState* __tstate = wxPyBeginAllowThreads();
9564 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9565
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 Py_INCREF(Py_None); resultobj = Py_None;
9570 {
9571 if (temp1)
9572 delete arg1;
9573 }
9574 return resultobj;
9575 fail:
9576 {
9577 if (temp1)
9578 delete arg1;
9579 }
9580 return NULL;
9581 }
9582
9583
9584 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj;
9586 wxString *arg1 = 0 ;
9587 PyObject *arg2 = (PyObject *) 0 ;
9588 bool temp1 = false ;
9589 PyObject * obj0 = 0 ;
9590 PyObject * obj1 = 0 ;
9591 char *kwnames[] = {
9592 (char *) "filename",(char *) "data", NULL
9593 };
9594
9595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9596 {
9597 arg1 = wxString_in_helper(obj0);
9598 if (arg1 == NULL) SWIG_fail;
9599 temp1 = true;
9600 }
9601 arg2 = obj1;
9602 {
9603 PyThreadState* __tstate = wxPyBeginAllowThreads();
9604 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9605
9606 wxPyEndAllowThreads(__tstate);
9607 if (PyErr_Occurred()) SWIG_fail;
9608 }
9609 Py_INCREF(Py_None); resultobj = Py_None;
9610 {
9611 if (temp1)
9612 delete arg1;
9613 }
9614 return resultobj;
9615 fail:
9616 {
9617 if (temp1)
9618 delete arg1;
9619 }
9620 return NULL;
9621 }
9622
9623
9624 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9625 PyObject *resultobj;
9626 wxMemoryFSHandler *result;
9627 char *kwnames[] = {
9628 NULL
9629 };
9630
9631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj;
9648 wxString *arg1 = 0 ;
9649 bool temp1 = false ;
9650 PyObject * obj0 = 0 ;
9651 char *kwnames[] = {
9652 (char *) "filename", NULL
9653 };
9654
9655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9656 {
9657 arg1 = wxString_in_helper(obj0);
9658 if (arg1 == NULL) SWIG_fail;
9659 temp1 = true;
9660 }
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9664
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 Py_INCREF(Py_None); resultobj = Py_None;
9669 {
9670 if (temp1)
9671 delete arg1;
9672 }
9673 return resultobj;
9674 fail:
9675 {
9676 if (temp1)
9677 delete arg1;
9678 }
9679 return NULL;
9680 }
9681
9682
9683 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9684 PyObject *resultobj;
9685 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9686 wxString *arg2 = 0 ;
9687 bool result;
9688 bool temp2 = false ;
9689 PyObject * obj0 = 0 ;
9690 PyObject * obj1 = 0 ;
9691 char *kwnames[] = {
9692 (char *) "self",(char *) "location", NULL
9693 };
9694
9695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9697 if (SWIG_arg_fail(1)) SWIG_fail;
9698 {
9699 arg2 = wxString_in_helper(obj1);
9700 if (arg2 == NULL) SWIG_fail;
9701 temp2 = true;
9702 }
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 {
9711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9712 }
9713 {
9714 if (temp2)
9715 delete arg2;
9716 }
9717 return resultobj;
9718 fail:
9719 {
9720 if (temp2)
9721 delete arg2;
9722 }
9723 return NULL;
9724 }
9725
9726
9727 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9728 PyObject *resultobj;
9729 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9730 wxFileSystem *arg2 = 0 ;
9731 wxString *arg3 = 0 ;
9732 wxFSFile *result;
9733 bool temp3 = false ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 PyObject * obj2 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "self",(char *) "fs",(char *) "location", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9743 if (SWIG_arg_fail(1)) SWIG_fail;
9744 {
9745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(2)) SWIG_fail;
9747 if (arg2 == NULL) {
9748 SWIG_null_ref("wxFileSystem");
9749 }
9750 if (SWIG_arg_fail(2)) SWIG_fail;
9751 }
9752 {
9753 arg3 = wxString_in_helper(obj2);
9754 if (arg3 == NULL) SWIG_fail;
9755 temp3 = true;
9756 }
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 resultobj = wxPyMake_wxObject(result, 1);
9766 }
9767 {
9768 if (temp3)
9769 delete arg3;
9770 }
9771 return resultobj;
9772 fail:
9773 {
9774 if (temp3)
9775 delete arg3;
9776 }
9777 return NULL;
9778 }
9779
9780
9781 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj;
9783 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9784 wxString *arg2 = 0 ;
9785 int arg3 = (int) 0 ;
9786 wxString result;
9787 bool temp2 = false ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 PyObject * obj2 = 0 ;
9791 char *kwnames[] = {
9792 (char *) "self",(char *) "spec",(char *) "flags", NULL
9793 };
9794
9795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9797 if (SWIG_arg_fail(1)) SWIG_fail;
9798 {
9799 arg2 = wxString_in_helper(obj1);
9800 if (arg2 == NULL) SWIG_fail;
9801 temp2 = true;
9802 }
9803 if (obj2) {
9804 {
9805 arg3 = (int)(SWIG_As_int(obj2));
9806 if (SWIG_arg_fail(3)) SWIG_fail;
9807 }
9808 }
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9812
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 {
9817 #if wxUSE_UNICODE
9818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9819 #else
9820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9821 #endif
9822 }
9823 {
9824 if (temp2)
9825 delete arg2;
9826 }
9827 return resultobj;
9828 fail:
9829 {
9830 if (temp2)
9831 delete arg2;
9832 }
9833 return NULL;
9834 }
9835
9836
9837 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9838 PyObject *resultobj;
9839 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9840 wxString result;
9841 PyObject * obj0 = 0 ;
9842 char *kwnames[] = {
9843 (char *) "self", NULL
9844 };
9845
9846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9848 if (SWIG_arg_fail(1)) SWIG_fail;
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 result = (arg1)->FindNext();
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 {
9857 #if wxUSE_UNICODE
9858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9859 #else
9860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9861 #endif
9862 }
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9870 PyObject *obj;
9871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9872 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9873 Py_INCREF(obj);
9874 return Py_BuildValue((char *)"");
9875 }
9876 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj;
9878 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9879 wxString result;
9880 PyObject * obj0 = 0 ;
9881 char *kwnames[] = {
9882 (char *) "self", NULL
9883 };
9884
9885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9887 if (SWIG_arg_fail(1)) SWIG_fail;
9888 {
9889 PyThreadState* __tstate = wxPyBeginAllowThreads();
9890 result = (arg1)->GetName();
9891
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 {
9896 #if wxUSE_UNICODE
9897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9898 #else
9899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9900 #endif
9901 }
9902 return resultobj;
9903 fail:
9904 return NULL;
9905 }
9906
9907
9908 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9909 PyObject *resultobj;
9910 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9911 wxString result;
9912 PyObject * obj0 = 0 ;
9913 char *kwnames[] = {
9914 (char *) "self", NULL
9915 };
9916
9917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9919 if (SWIG_arg_fail(1)) SWIG_fail;
9920 {
9921 PyThreadState* __tstate = wxPyBeginAllowThreads();
9922 result = (arg1)->GetExtension();
9923
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 {
9928 #if wxUSE_UNICODE
9929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9930 #else
9931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9932 #endif
9933 }
9934 return resultobj;
9935 fail:
9936 return NULL;
9937 }
9938
9939
9940 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9941 PyObject *resultobj;
9942 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9943 long result;
9944 PyObject * obj0 = 0 ;
9945 char *kwnames[] = {
9946 (char *) "self", NULL
9947 };
9948
9949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9951 if (SWIG_arg_fail(1)) SWIG_fail;
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 result = (long)(arg1)->GetType();
9955
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 {
9960 resultobj = SWIG_From_long((long)(result));
9961 }
9962 return resultobj;
9963 fail:
9964 return NULL;
9965 }
9966
9967
9968 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9969 PyObject *resultobj;
9970 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9971 wxString result;
9972 PyObject * obj0 = 0 ;
9973 char *kwnames[] = {
9974 (char *) "self", NULL
9975 };
9976
9977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9979 if (SWIG_arg_fail(1)) SWIG_fail;
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 result = (arg1)->GetMimeType();
9983
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 {
9988 #if wxUSE_UNICODE
9989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9990 #else
9991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9992 #endif
9993 }
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10001 PyObject *resultobj;
10002 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10003 wxString *arg2 = 0 ;
10004 bool result;
10005 bool temp2 = false ;
10006 PyObject * obj0 = 0 ;
10007 PyObject * obj1 = 0 ;
10008 char *kwnames[] = {
10009 (char *) "self",(char *) "name", NULL
10010 };
10011
10012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10014 if (SWIG_arg_fail(1)) SWIG_fail;
10015 {
10016 arg2 = wxString_in_helper(obj1);
10017 if (arg2 == NULL) SWIG_fail;
10018 temp2 = true;
10019 }
10020 {
10021 PyThreadState* __tstate = wxPyBeginAllowThreads();
10022 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10023
10024 wxPyEndAllowThreads(__tstate);
10025 if (PyErr_Occurred()) SWIG_fail;
10026 }
10027 {
10028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10029 }
10030 {
10031 if (temp2)
10032 delete arg2;
10033 }
10034 return resultobj;
10035 fail:
10036 {
10037 if (temp2)
10038 delete arg2;
10039 }
10040 return NULL;
10041 }
10042
10043
10044 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj;
10046 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10047 wxString *arg2 = 0 ;
10048 bool temp2 = false ;
10049 PyObject * obj0 = 0 ;
10050 PyObject * obj1 = 0 ;
10051 char *kwnames[] = {
10052 (char *) "self",(char *) "name", NULL
10053 };
10054
10055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10057 if (SWIG_arg_fail(1)) SWIG_fail;
10058 {
10059 arg2 = wxString_in_helper(obj1);
10060 if (arg2 == NULL) SWIG_fail;
10061 temp2 = true;
10062 }
10063 {
10064 PyThreadState* __tstate = wxPyBeginAllowThreads();
10065 (arg1)->SetName((wxString const &)*arg2);
10066
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 Py_INCREF(Py_None); resultobj = Py_None;
10071 {
10072 if (temp2)
10073 delete arg2;
10074 }
10075 return resultobj;
10076 fail:
10077 {
10078 if (temp2)
10079 delete arg2;
10080 }
10081 return NULL;
10082 }
10083
10084
10085 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj;
10087 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10088 wxString *arg2 = 0 ;
10089 bool temp2 = false ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "extension", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10098 if (SWIG_arg_fail(1)) SWIG_fail;
10099 {
10100 arg2 = wxString_in_helper(obj1);
10101 if (arg2 == NULL) SWIG_fail;
10102 temp2 = true;
10103 }
10104 {
10105 PyThreadState* __tstate = wxPyBeginAllowThreads();
10106 (arg1)->SetExtension((wxString const &)*arg2);
10107
10108 wxPyEndAllowThreads(__tstate);
10109 if (PyErr_Occurred()) SWIG_fail;
10110 }
10111 Py_INCREF(Py_None); resultobj = Py_None;
10112 {
10113 if (temp2)
10114 delete arg2;
10115 }
10116 return resultobj;
10117 fail:
10118 {
10119 if (temp2)
10120 delete arg2;
10121 }
10122 return NULL;
10123 }
10124
10125
10126 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10127 PyObject *resultobj;
10128 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10129 long arg2 ;
10130 PyObject * obj0 = 0 ;
10131 PyObject * obj1 = 0 ;
10132 char *kwnames[] = {
10133 (char *) "self",(char *) "type", NULL
10134 };
10135
10136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10138 if (SWIG_arg_fail(1)) SWIG_fail;
10139 {
10140 arg2 = (long)(SWIG_As_long(obj1));
10141 if (SWIG_arg_fail(2)) SWIG_fail;
10142 }
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 (arg1)->SetType(arg2);
10146
10147 wxPyEndAllowThreads(__tstate);
10148 if (PyErr_Occurred()) SWIG_fail;
10149 }
10150 Py_INCREF(Py_None); resultobj = Py_None;
10151 return resultobj;
10152 fail:
10153 return NULL;
10154 }
10155
10156
10157 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10158 PyObject *resultobj;
10159 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10160 wxString *arg2 = 0 ;
10161 bool temp2 = false ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "mimetype", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 arg2 = wxString_in_helper(obj1);
10173 if (arg2 == NULL) SWIG_fail;
10174 temp2 = true;
10175 }
10176 {
10177 PyThreadState* __tstate = wxPyBeginAllowThreads();
10178 (arg1)->SetMimeType((wxString const &)*arg2);
10179
10180 wxPyEndAllowThreads(__tstate);
10181 if (PyErr_Occurred()) SWIG_fail;
10182 }
10183 Py_INCREF(Py_None); resultobj = Py_None;
10184 {
10185 if (temp2)
10186 delete arg2;
10187 }
10188 return resultobj;
10189 fail:
10190 {
10191 if (temp2)
10192 delete arg2;
10193 }
10194 return NULL;
10195 }
10196
10197
10198 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10199 PyObject *obj;
10200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10201 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10202 Py_INCREF(obj);
10203 return Py_BuildValue((char *)"");
10204 }
10205 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10206 PyObject *resultobj;
10207 wxImageHistogram *result;
10208 char *kwnames[] = {
10209 NULL
10210 };
10211
10212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10213 {
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 result = (wxImageHistogram *)new wxImageHistogram();
10216
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj;
10229 unsigned char arg1 ;
10230 unsigned char arg2 ;
10231 unsigned char arg3 ;
10232 unsigned long result;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 PyObject * obj2 = 0 ;
10236 char *kwnames[] = {
10237 (char *) "r",(char *) "g",(char *) "b", NULL
10238 };
10239
10240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10241 {
10242 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10243 if (SWIG_arg_fail(1)) SWIG_fail;
10244 }
10245 {
10246 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10247 if (SWIG_arg_fail(2)) SWIG_fail;
10248 }
10249 {
10250 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10251 if (SWIG_arg_fail(3)) SWIG_fail;
10252 }
10253 {
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10256
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 {
10261 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10262 }
10263 return resultobj;
10264 fail:
10265 return NULL;
10266 }
10267
10268
10269 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10270 PyObject *resultobj;
10271 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10272 unsigned char *arg2 = (unsigned char *) 0 ;
10273 unsigned char *arg3 = (unsigned char *) 0 ;
10274 unsigned char *arg4 = (unsigned char *) 0 ;
10275 unsigned char arg5 = (unsigned char) 1 ;
10276 unsigned char arg6 = (unsigned char) 0 ;
10277 unsigned char arg7 = (unsigned char) 0 ;
10278 bool result;
10279 unsigned char temp2 ;
10280 int res2 = 0 ;
10281 unsigned char temp3 ;
10282 int res3 = 0 ;
10283 unsigned char temp4 ;
10284 int res4 = 0 ;
10285 PyObject * obj0 = 0 ;
10286 PyObject * obj1 = 0 ;
10287 PyObject * obj2 = 0 ;
10288 PyObject * obj3 = 0 ;
10289 char *kwnames[] = {
10290 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10291 };
10292
10293 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10294 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10295 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10298 if (SWIG_arg_fail(1)) SWIG_fail;
10299 if (obj1) {
10300 {
10301 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10302 if (SWIG_arg_fail(5)) SWIG_fail;
10303 }
10304 }
10305 if (obj2) {
10306 {
10307 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10308 if (SWIG_arg_fail(6)) SWIG_fail;
10309 }
10310 }
10311 if (obj3) {
10312 {
10313 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10314 if (SWIG_arg_fail(7)) SWIG_fail;
10315 }
10316 }
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10320
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 {
10325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10326 }
10327 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10328 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10329 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10330 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10331 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10332 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10333 return resultobj;
10334 fail:
10335 return NULL;
10336 }
10337
10338
10339 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10340 PyObject *resultobj;
10341 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10342 unsigned long arg2 ;
10343 unsigned long result;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 char *kwnames[] = {
10347 (char *) "self",(char *) "key", NULL
10348 };
10349
10350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10352 if (SWIG_arg_fail(1)) SWIG_fail;
10353 {
10354 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10355 if (SWIG_arg_fail(2)) SWIG_fail;
10356 }
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10360
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 {
10365 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10366 }
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10376 unsigned char arg2 ;
10377 unsigned char arg3 ;
10378 unsigned char arg4 ;
10379 unsigned long result;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 PyObject * obj2 = 0 ;
10383 PyObject * obj3 = 0 ;
10384 char *kwnames[] = {
10385 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10386 };
10387
10388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10390 if (SWIG_arg_fail(1)) SWIG_fail;
10391 {
10392 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10393 if (SWIG_arg_fail(2)) SWIG_fail;
10394 }
10395 {
10396 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10397 if (SWIG_arg_fail(3)) SWIG_fail;
10398 }
10399 {
10400 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10401 if (SWIG_arg_fail(4)) SWIG_fail;
10402 }
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10406
10407 wxPyEndAllowThreads(__tstate);
10408 if (PyErr_Occurred()) SWIG_fail;
10409 }
10410 {
10411 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10412 }
10413 return resultobj;
10414 fail:
10415 return NULL;
10416 }
10417
10418
10419 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10420 PyObject *resultobj;
10421 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10422 wxColour *arg2 = 0 ;
10423 unsigned long result;
10424 wxColour temp2 ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 char *kwnames[] = {
10428 (char *) "self",(char *) "colour", NULL
10429 };
10430
10431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10433 if (SWIG_arg_fail(1)) SWIG_fail;
10434 {
10435 arg2 = &temp2;
10436 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10437 }
10438 {
10439 PyThreadState* __tstate = wxPyBeginAllowThreads();
10440 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10441
10442 wxPyEndAllowThreads(__tstate);
10443 if (PyErr_Occurred()) SWIG_fail;
10444 }
10445 {
10446 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10447 }
10448 return resultobj;
10449 fail:
10450 return NULL;
10451 }
10452
10453
10454 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10455 PyObject *obj;
10456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10457 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10458 Py_INCREF(obj);
10459 return Py_BuildValue((char *)"");
10460 }
10461 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10462 PyObject *resultobj;
10463 wxString *arg1 = 0 ;
10464 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10465 int arg3 = (int) -1 ;
10466 wxImage *result;
10467 bool temp1 = false ;
10468 PyObject * obj0 = 0 ;
10469 PyObject * obj1 = 0 ;
10470 PyObject * obj2 = 0 ;
10471 char *kwnames[] = {
10472 (char *) "name",(char *) "type",(char *) "index", NULL
10473 };
10474
10475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10476 {
10477 arg1 = wxString_in_helper(obj0);
10478 if (arg1 == NULL) SWIG_fail;
10479 temp1 = true;
10480 }
10481 if (obj1) {
10482 {
10483 arg2 = (long)(SWIG_As_long(obj1));
10484 if (SWIG_arg_fail(2)) SWIG_fail;
10485 }
10486 }
10487 if (obj2) {
10488 {
10489 arg3 = (int)(SWIG_As_int(obj2));
10490 if (SWIG_arg_fail(3)) SWIG_fail;
10491 }
10492 }
10493 {
10494 PyThreadState* __tstate = wxPyBeginAllowThreads();
10495 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10496
10497 wxPyEndAllowThreads(__tstate);
10498 if (PyErr_Occurred()) SWIG_fail;
10499 }
10500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10501 {
10502 if (temp1)
10503 delete arg1;
10504 }
10505 return resultobj;
10506 fail:
10507 {
10508 if (temp1)
10509 delete arg1;
10510 }
10511 return NULL;
10512 }
10513
10514
10515 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj;
10517 wxImage *arg1 = (wxImage *) 0 ;
10518 PyObject * obj0 = 0 ;
10519 char *kwnames[] = {
10520 (char *) "self", NULL
10521 };
10522
10523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10525 if (SWIG_arg_fail(1)) SWIG_fail;
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 delete arg1;
10529
10530 wxPyEndAllowThreads(__tstate);
10531 if (PyErr_Occurred()) SWIG_fail;
10532 }
10533 Py_INCREF(Py_None); resultobj = Py_None;
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10541 PyObject *resultobj;
10542 wxString *arg1 = 0 ;
10543 wxString *arg2 = 0 ;
10544 int arg3 = (int) -1 ;
10545 wxImage *result;
10546 bool temp1 = false ;
10547 bool temp2 = false ;
10548 PyObject * obj0 = 0 ;
10549 PyObject * obj1 = 0 ;
10550 PyObject * obj2 = 0 ;
10551 char *kwnames[] = {
10552 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10553 };
10554
10555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10556 {
10557 arg1 = wxString_in_helper(obj0);
10558 if (arg1 == NULL) SWIG_fail;
10559 temp1 = true;
10560 }
10561 {
10562 arg2 = wxString_in_helper(obj1);
10563 if (arg2 == NULL) SWIG_fail;
10564 temp2 = true;
10565 }
10566 if (obj2) {
10567 {
10568 arg3 = (int)(SWIG_As_int(obj2));
10569 if (SWIG_arg_fail(3)) SWIG_fail;
10570 }
10571 }
10572 {
10573 PyThreadState* __tstate = wxPyBeginAllowThreads();
10574 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10575
10576 wxPyEndAllowThreads(__tstate);
10577 if (PyErr_Occurred()) SWIG_fail;
10578 }
10579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10580 {
10581 if (temp1)
10582 delete arg1;
10583 }
10584 {
10585 if (temp2)
10586 delete arg2;
10587 }
10588 return resultobj;
10589 fail:
10590 {
10591 if (temp1)
10592 delete arg1;
10593 }
10594 {
10595 if (temp2)
10596 delete arg2;
10597 }
10598 return NULL;
10599 }
10600
10601
10602 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10603 PyObject *resultobj;
10604 wxInputStream *arg1 = 0 ;
10605 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10606 int arg3 = (int) -1 ;
10607 wxImage *result;
10608 wxPyInputStream *temp1 ;
10609 bool created1 ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612 PyObject * obj2 = 0 ;
10613 char *kwnames[] = {
10614 (char *) "stream",(char *) "type",(char *) "index", NULL
10615 };
10616
10617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10618 {
10619 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10620 arg1 = temp1->m_wxis;
10621 created1 = false;
10622 } else {
10623 PyErr_Clear(); // clear the failure of the wxPyConvert above
10624 arg1 = wxPyCBInputStream_create(obj0, false);
10625 if (arg1 == NULL) {
10626 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10627 SWIG_fail;
10628 }
10629 created1 = true;
10630 }
10631 }
10632 if (obj1) {
10633 {
10634 arg2 = (long)(SWIG_As_long(obj1));
10635 if (SWIG_arg_fail(2)) SWIG_fail;
10636 }
10637 }
10638 if (obj2) {
10639 {
10640 arg3 = (int)(SWIG_As_int(obj2));
10641 if (SWIG_arg_fail(3)) SWIG_fail;
10642 }
10643 }
10644 {
10645 PyThreadState* __tstate = wxPyBeginAllowThreads();
10646 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10647
10648 wxPyEndAllowThreads(__tstate);
10649 if (PyErr_Occurred()) SWIG_fail;
10650 }
10651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10652 {
10653 if (created1) delete arg1;
10654 }
10655 return resultobj;
10656 fail:
10657 {
10658 if (created1) delete arg1;
10659 }
10660 return NULL;
10661 }
10662
10663
10664 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj;
10666 wxInputStream *arg1 = 0 ;
10667 wxString *arg2 = 0 ;
10668 int arg3 = (int) -1 ;
10669 wxImage *result;
10670 wxPyInputStream *temp1 ;
10671 bool created1 ;
10672 bool temp2 = false ;
10673 PyObject * obj0 = 0 ;
10674 PyObject * obj1 = 0 ;
10675 PyObject * obj2 = 0 ;
10676 char *kwnames[] = {
10677 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10678 };
10679
10680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10681 {
10682 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10683 arg1 = temp1->m_wxis;
10684 created1 = false;
10685 } else {
10686 PyErr_Clear(); // clear the failure of the wxPyConvert above
10687 arg1 = wxPyCBInputStream_create(obj0, false);
10688 if (arg1 == NULL) {
10689 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10690 SWIG_fail;
10691 }
10692 created1 = true;
10693 }
10694 }
10695 {
10696 arg2 = wxString_in_helper(obj1);
10697 if (arg2 == NULL) SWIG_fail;
10698 temp2 = true;
10699 }
10700 if (obj2) {
10701 {
10702 arg3 = (int)(SWIG_As_int(obj2));
10703 if (SWIG_arg_fail(3)) SWIG_fail;
10704 }
10705 }
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10709
10710 wxPyEndAllowThreads(__tstate);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10714 {
10715 if (created1) delete arg1;
10716 }
10717 {
10718 if (temp2)
10719 delete arg2;
10720 }
10721 return resultobj;
10722 fail:
10723 {
10724 if (created1) delete arg1;
10725 }
10726 {
10727 if (temp2)
10728 delete arg2;
10729 }
10730 return NULL;
10731 }
10732
10733
10734 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj;
10736 int arg1 = (int) 0 ;
10737 int arg2 = (int) 0 ;
10738 bool arg3 = (bool) true ;
10739 wxImage *result;
10740 PyObject * obj0 = 0 ;
10741 PyObject * obj1 = 0 ;
10742 PyObject * obj2 = 0 ;
10743 char *kwnames[] = {
10744 (char *) "width",(char *) "height",(char *) "clear", NULL
10745 };
10746
10747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10748 if (obj0) {
10749 {
10750 arg1 = (int)(SWIG_As_int(obj0));
10751 if (SWIG_arg_fail(1)) SWIG_fail;
10752 }
10753 }
10754 if (obj1) {
10755 {
10756 arg2 = (int)(SWIG_As_int(obj1));
10757 if (SWIG_arg_fail(2)) SWIG_fail;
10758 }
10759 }
10760 if (obj2) {
10761 {
10762 arg3 = (bool)(SWIG_As_bool(obj2));
10763 if (SWIG_arg_fail(3)) SWIG_fail;
10764 }
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj;
10782 wxBitmap *arg1 = 0 ;
10783 wxImage *result;
10784 PyObject * obj0 = 0 ;
10785 char *kwnames[] = {
10786 (char *) "bitmap", NULL
10787 };
10788
10789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10790 {
10791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10792 if (SWIG_arg_fail(1)) SWIG_fail;
10793 if (arg1 == NULL) {
10794 SWIG_null_ref("wxBitmap");
10795 }
10796 if (SWIG_arg_fail(1)) SWIG_fail;
10797 }
10798 {
10799 if (!wxPyCheckForApp()) SWIG_fail;
10800 PyThreadState* __tstate = wxPyBeginAllowThreads();
10801 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10802
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 int arg1 ;
10816 int arg2 ;
10817 buffer arg3 ;
10818 int arg4 ;
10819 wxImage *result;
10820 PyObject * obj0 = 0 ;
10821 PyObject * obj1 = 0 ;
10822 PyObject * obj2 = 0 ;
10823 char *kwnames[] = {
10824 (char *) "width",(char *) "height",(char *) "data", NULL
10825 };
10826
10827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10828 {
10829 arg1 = (int)(SWIG_As_int(obj0));
10830 if (SWIG_arg_fail(1)) SWIG_fail;
10831 }
10832 {
10833 arg2 = (int)(SWIG_As_int(obj1));
10834 if (SWIG_arg_fail(2)) SWIG_fail;
10835 }
10836 {
10837 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10838 }
10839 {
10840 PyThreadState* __tstate = wxPyBeginAllowThreads();
10841 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10842
10843 wxPyEndAllowThreads(__tstate);
10844 if (PyErr_Occurred()) SWIG_fail;
10845 }
10846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10847 return resultobj;
10848 fail:
10849 return NULL;
10850 }
10851
10852
10853 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10854 PyObject *resultobj;
10855 int arg1 ;
10856 int arg2 ;
10857 buffer arg3 ;
10858 int arg4 ;
10859 buffer arg5 ;
10860 int arg6 ;
10861 wxImage *result;
10862 PyObject * obj0 = 0 ;
10863 PyObject * obj1 = 0 ;
10864 PyObject * obj2 = 0 ;
10865 PyObject * obj3 = 0 ;
10866 char *kwnames[] = {
10867 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10868 };
10869
10870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10871 {
10872 arg1 = (int)(SWIG_As_int(obj0));
10873 if (SWIG_arg_fail(1)) SWIG_fail;
10874 }
10875 {
10876 arg2 = (int)(SWIG_As_int(obj1));
10877 if (SWIG_arg_fail(2)) SWIG_fail;
10878 }
10879 {
10880 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10881 }
10882 {
10883 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10884 }
10885 {
10886 PyThreadState* __tstate = wxPyBeginAllowThreads();
10887 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10888
10889 wxPyEndAllowThreads(__tstate);
10890 if (PyErr_Occurred()) SWIG_fail;
10891 }
10892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj;
10901 wxImage *arg1 = (wxImage *) 0 ;
10902 int arg2 ;
10903 int arg3 ;
10904 PyObject * obj0 = 0 ;
10905 PyObject * obj1 = 0 ;
10906 PyObject * obj2 = 0 ;
10907 char *kwnames[] = {
10908 (char *) "self",(char *) "width",(char *) "height", NULL
10909 };
10910
10911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10913 if (SWIG_arg_fail(1)) SWIG_fail;
10914 {
10915 arg2 = (int)(SWIG_As_int(obj1));
10916 if (SWIG_arg_fail(2)) SWIG_fail;
10917 }
10918 {
10919 arg3 = (int)(SWIG_As_int(obj2));
10920 if (SWIG_arg_fail(3)) SWIG_fail;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 (arg1)->Create(arg2,arg3);
10925
10926 wxPyEndAllowThreads(__tstate);
10927 if (PyErr_Occurred()) SWIG_fail;
10928 }
10929 Py_INCREF(Py_None); resultobj = Py_None;
10930 return resultobj;
10931 fail:
10932 return NULL;
10933 }
10934
10935
10936 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj;
10938 wxImage *arg1 = (wxImage *) 0 ;
10939 PyObject * obj0 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "self", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 (arg1)->Destroy();
10950
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 Py_INCREF(Py_None); resultobj = Py_None;
10955 return resultobj;
10956 fail:
10957 return NULL;
10958 }
10959
10960
10961 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10962 PyObject *resultobj;
10963 wxImage *arg1 = (wxImage *) 0 ;
10964 int arg2 ;
10965 int arg3 ;
10966 SwigValueWrapper<wxImage > result;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 PyObject * obj2 = 0 ;
10970 char *kwnames[] = {
10971 (char *) "self",(char *) "width",(char *) "height", NULL
10972 };
10973
10974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10976 if (SWIG_arg_fail(1)) SWIG_fail;
10977 {
10978 arg2 = (int)(SWIG_As_int(obj1));
10979 if (SWIG_arg_fail(2)) SWIG_fail;
10980 }
10981 {
10982 arg3 = (int)(SWIG_As_int(obj2));
10983 if (SWIG_arg_fail(3)) SWIG_fail;
10984 }
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 result = (arg1)->Scale(arg2,arg3);
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 {
10993 wxImage * resultptr;
10994 resultptr = new wxImage((wxImage &)(result));
10995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10996 }
10997 return resultobj;
10998 fail:
10999 return NULL;
11000 }
11001
11002
11003 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11004 PyObject *resultobj;
11005 wxImage *arg1 = (wxImage *) 0 ;
11006 int arg2 ;
11007 int arg3 ;
11008 SwigValueWrapper<wxImage > result;
11009 PyObject * obj0 = 0 ;
11010 PyObject * obj1 = 0 ;
11011 PyObject * obj2 = 0 ;
11012 char *kwnames[] = {
11013 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11014 };
11015
11016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11018 if (SWIG_arg_fail(1)) SWIG_fail;
11019 {
11020 arg2 = (int)(SWIG_As_int(obj1));
11021 if (SWIG_arg_fail(2)) SWIG_fail;
11022 }
11023 {
11024 arg3 = (int)(SWIG_As_int(obj2));
11025 if (SWIG_arg_fail(3)) SWIG_fail;
11026 }
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11030
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 {
11035 wxImage * resultptr;
11036 resultptr = new wxImage((wxImage &)(result));
11037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11038 }
11039 return resultobj;
11040 fail:
11041 return NULL;
11042 }
11043
11044
11045 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11046 PyObject *resultobj;
11047 wxImage *arg1 = (wxImage *) 0 ;
11048 int arg2 ;
11049 int arg3 ;
11050 wxImage *result;
11051 PyObject * obj0 = 0 ;
11052 PyObject * obj1 = 0 ;
11053 PyObject * obj2 = 0 ;
11054 char *kwnames[] = {
11055 (char *) "self",(char *) "width",(char *) "height", NULL
11056 };
11057
11058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11060 if (SWIG_arg_fail(1)) SWIG_fail;
11061 {
11062 arg2 = (int)(SWIG_As_int(obj1));
11063 if (SWIG_arg_fail(2)) SWIG_fail;
11064 }
11065 {
11066 arg3 = (int)(SWIG_As_int(obj2));
11067 if (SWIG_arg_fail(3)) SWIG_fail;
11068 }
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 {
11072 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11073 result = (wxImage *) &_result_ref;
11074 }
11075
11076 wxPyEndAllowThreads(__tstate);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11080 return resultobj;
11081 fail:
11082 return NULL;
11083 }
11084
11085
11086 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11087 PyObject *resultobj;
11088 wxImage *arg1 = (wxImage *) 0 ;
11089 wxSize *arg2 = 0 ;
11090 wxPoint *arg3 = 0 ;
11091 int arg4 = (int) -1 ;
11092 int arg5 = (int) -1 ;
11093 int arg6 = (int) -1 ;
11094 wxImage *result;
11095 wxSize temp2 ;
11096 wxPoint temp3 ;
11097 PyObject * obj0 = 0 ;
11098 PyObject * obj1 = 0 ;
11099 PyObject * obj2 = 0 ;
11100 PyObject * obj3 = 0 ;
11101 PyObject * obj4 = 0 ;
11102 PyObject * obj5 = 0 ;
11103 char *kwnames[] = {
11104 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11105 };
11106
11107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11109 if (SWIG_arg_fail(1)) SWIG_fail;
11110 {
11111 arg2 = &temp2;
11112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11113 }
11114 {
11115 arg3 = &temp3;
11116 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11117 }
11118 if (obj3) {
11119 {
11120 arg4 = (int)(SWIG_As_int(obj3));
11121 if (SWIG_arg_fail(4)) SWIG_fail;
11122 }
11123 }
11124 if (obj4) {
11125 {
11126 arg5 = (int)(SWIG_As_int(obj4));
11127 if (SWIG_arg_fail(5)) SWIG_fail;
11128 }
11129 }
11130 if (obj5) {
11131 {
11132 arg6 = (int)(SWIG_As_int(obj5));
11133 if (SWIG_arg_fail(6)) SWIG_fail;
11134 }
11135 }
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 {
11139 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11140 result = (wxImage *) &_result_ref;
11141 }
11142
11143 wxPyEndAllowThreads(__tstate);
11144 if (PyErr_Occurred()) SWIG_fail;
11145 }
11146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11154 PyObject *resultobj;
11155 wxImage *arg1 = (wxImage *) 0 ;
11156 int arg2 ;
11157 int arg3 ;
11158 unsigned char arg4 ;
11159 unsigned char arg5 ;
11160 unsigned char arg6 ;
11161 PyObject * obj0 = 0 ;
11162 PyObject * obj1 = 0 ;
11163 PyObject * obj2 = 0 ;
11164 PyObject * obj3 = 0 ;
11165 PyObject * obj4 = 0 ;
11166 PyObject * obj5 = 0 ;
11167 char *kwnames[] = {
11168 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11169 };
11170
11171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11173 if (SWIG_arg_fail(1)) SWIG_fail;
11174 {
11175 arg2 = (int)(SWIG_As_int(obj1));
11176 if (SWIG_arg_fail(2)) SWIG_fail;
11177 }
11178 {
11179 arg3 = (int)(SWIG_As_int(obj2));
11180 if (SWIG_arg_fail(3)) SWIG_fail;
11181 }
11182 {
11183 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11184 if (SWIG_arg_fail(4)) SWIG_fail;
11185 }
11186 {
11187 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11188 if (SWIG_arg_fail(5)) SWIG_fail;
11189 }
11190 {
11191 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11192 if (SWIG_arg_fail(6)) SWIG_fail;
11193 }
11194 {
11195 PyThreadState* __tstate = wxPyBeginAllowThreads();
11196 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11197
11198 wxPyEndAllowThreads(__tstate);
11199 if (PyErr_Occurred()) SWIG_fail;
11200 }
11201 Py_INCREF(Py_None); resultobj = Py_None;
11202 return resultobj;
11203 fail:
11204 return NULL;
11205 }
11206
11207
11208 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj;
11210 wxImage *arg1 = (wxImage *) 0 ;
11211 wxRect *arg2 = 0 ;
11212 unsigned char arg3 ;
11213 unsigned char arg4 ;
11214 unsigned char arg5 ;
11215 wxRect temp2 ;
11216 PyObject * obj0 = 0 ;
11217 PyObject * obj1 = 0 ;
11218 PyObject * obj2 = 0 ;
11219 PyObject * obj3 = 0 ;
11220 PyObject * obj4 = 0 ;
11221 char *kwnames[] = {
11222 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11223 };
11224
11225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11227 if (SWIG_arg_fail(1)) SWIG_fail;
11228 {
11229 arg2 = &temp2;
11230 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11231 }
11232 {
11233 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11234 if (SWIG_arg_fail(3)) SWIG_fail;
11235 }
11236 {
11237 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11238 if (SWIG_arg_fail(4)) SWIG_fail;
11239 }
11240 {
11241 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11242 if (SWIG_arg_fail(5)) SWIG_fail;
11243 }
11244 {
11245 PyThreadState* __tstate = wxPyBeginAllowThreads();
11246 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11247
11248 wxPyEndAllowThreads(__tstate);
11249 if (PyErr_Occurred()) SWIG_fail;
11250 }
11251 Py_INCREF(Py_None); resultobj = Py_None;
11252 return resultobj;
11253 fail:
11254 return NULL;
11255 }
11256
11257
11258 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj;
11260 wxImage *arg1 = (wxImage *) 0 ;
11261 int arg2 ;
11262 int arg3 ;
11263 unsigned char result;
11264 PyObject * obj0 = 0 ;
11265 PyObject * obj1 = 0 ;
11266 PyObject * obj2 = 0 ;
11267 char *kwnames[] = {
11268 (char *) "self",(char *) "x",(char *) "y", NULL
11269 };
11270
11271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11273 if (SWIG_arg_fail(1)) SWIG_fail;
11274 {
11275 arg2 = (int)(SWIG_As_int(obj1));
11276 if (SWIG_arg_fail(2)) SWIG_fail;
11277 }
11278 {
11279 arg3 = (int)(SWIG_As_int(obj2));
11280 if (SWIG_arg_fail(3)) SWIG_fail;
11281 }
11282 {
11283 PyThreadState* __tstate = wxPyBeginAllowThreads();
11284 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11285
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 {
11290 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11291 }
11292 return resultobj;
11293 fail:
11294 return NULL;
11295 }
11296
11297
11298 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11299 PyObject *resultobj;
11300 wxImage *arg1 = (wxImage *) 0 ;
11301 int arg2 ;
11302 int arg3 ;
11303 unsigned char result;
11304 PyObject * obj0 = 0 ;
11305 PyObject * obj1 = 0 ;
11306 PyObject * obj2 = 0 ;
11307 char *kwnames[] = {
11308 (char *) "self",(char *) "x",(char *) "y", NULL
11309 };
11310
11311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11313 if (SWIG_arg_fail(1)) SWIG_fail;
11314 {
11315 arg2 = (int)(SWIG_As_int(obj1));
11316 if (SWIG_arg_fail(2)) SWIG_fail;
11317 }
11318 {
11319 arg3 = (int)(SWIG_As_int(obj2));
11320 if (SWIG_arg_fail(3)) SWIG_fail;
11321 }
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11325
11326 wxPyEndAllowThreads(__tstate);
11327 if (PyErr_Occurred()) SWIG_fail;
11328 }
11329 {
11330 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11331 }
11332 return resultobj;
11333 fail:
11334 return NULL;
11335 }
11336
11337
11338 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11339 PyObject *resultobj;
11340 wxImage *arg1 = (wxImage *) 0 ;
11341 int arg2 ;
11342 int arg3 ;
11343 unsigned char result;
11344 PyObject * obj0 = 0 ;
11345 PyObject * obj1 = 0 ;
11346 PyObject * obj2 = 0 ;
11347 char *kwnames[] = {
11348 (char *) "self",(char *) "x",(char *) "y", NULL
11349 };
11350
11351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11353 if (SWIG_arg_fail(1)) SWIG_fail;
11354 {
11355 arg2 = (int)(SWIG_As_int(obj1));
11356 if (SWIG_arg_fail(2)) SWIG_fail;
11357 }
11358 {
11359 arg3 = (int)(SWIG_As_int(obj2));
11360 if (SWIG_arg_fail(3)) SWIG_fail;
11361 }
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11365
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 {
11370 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11371 }
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj;
11380 wxImage *arg1 = (wxImage *) 0 ;
11381 int arg2 ;
11382 int arg3 ;
11383 unsigned char arg4 ;
11384 PyObject * obj0 = 0 ;
11385 PyObject * obj1 = 0 ;
11386 PyObject * obj2 = 0 ;
11387 PyObject * obj3 = 0 ;
11388 char *kwnames[] = {
11389 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11390 };
11391
11392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11394 if (SWIG_arg_fail(1)) SWIG_fail;
11395 {
11396 arg2 = (int)(SWIG_As_int(obj1));
11397 if (SWIG_arg_fail(2)) SWIG_fail;
11398 }
11399 {
11400 arg3 = (int)(SWIG_As_int(obj2));
11401 if (SWIG_arg_fail(3)) SWIG_fail;
11402 }
11403 {
11404 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11405 if (SWIG_arg_fail(4)) SWIG_fail;
11406 }
11407 {
11408 PyThreadState* __tstate = wxPyBeginAllowThreads();
11409 (arg1)->SetAlpha(arg2,arg3,arg4);
11410
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 Py_INCREF(Py_None); resultobj = Py_None;
11415 return resultobj;
11416 fail:
11417 return NULL;
11418 }
11419
11420
11421 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11422 PyObject *resultobj;
11423 wxImage *arg1 = (wxImage *) 0 ;
11424 int arg2 ;
11425 int arg3 ;
11426 unsigned char result;
11427 PyObject * obj0 = 0 ;
11428 PyObject * obj1 = 0 ;
11429 PyObject * obj2 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "self",(char *) "x",(char *) "y", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(1)) SWIG_fail;
11437 {
11438 arg2 = (int)(SWIG_As_int(obj1));
11439 if (SWIG_arg_fail(2)) SWIG_fail;
11440 }
11441 {
11442 arg3 = (int)(SWIG_As_int(obj2));
11443 if (SWIG_arg_fail(3)) SWIG_fail;
11444 }
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11448
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 {
11453 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11454 }
11455 return resultobj;
11456 fail:
11457 return NULL;
11458 }
11459
11460
11461 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11462 PyObject *resultobj;
11463 wxImage *arg1 = (wxImage *) 0 ;
11464 bool result;
11465 PyObject * obj0 = 0 ;
11466 char *kwnames[] = {
11467 (char *) "self", NULL
11468 };
11469
11470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11472 if (SWIG_arg_fail(1)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (bool)(arg1)->HasAlpha();
11476
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 {
11481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11482 }
11483 return resultobj;
11484 fail:
11485 return NULL;
11486 }
11487
11488
11489 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11490 PyObject *resultobj;
11491 wxImage *arg1 = (wxImage *) 0 ;
11492 PyObject * obj0 = 0 ;
11493 char *kwnames[] = {
11494 (char *) "self", NULL
11495 };
11496
11497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11499 if (SWIG_arg_fail(1)) SWIG_fail;
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 (arg1)->InitAlpha();
11503
11504 wxPyEndAllowThreads(__tstate);
11505 if (PyErr_Occurred()) SWIG_fail;
11506 }
11507 Py_INCREF(Py_None); resultobj = Py_None;
11508 return resultobj;
11509 fail:
11510 return NULL;
11511 }
11512
11513
11514 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj;
11516 wxImage *arg1 = (wxImage *) 0 ;
11517 int arg2 ;
11518 int arg3 ;
11519 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11520 bool result;
11521 PyObject * obj0 = 0 ;
11522 PyObject * obj1 = 0 ;
11523 PyObject * obj2 = 0 ;
11524 PyObject * obj3 = 0 ;
11525 char *kwnames[] = {
11526 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11527 };
11528
11529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11531 if (SWIG_arg_fail(1)) SWIG_fail;
11532 {
11533 arg2 = (int)(SWIG_As_int(obj1));
11534 if (SWIG_arg_fail(2)) SWIG_fail;
11535 }
11536 {
11537 arg3 = (int)(SWIG_As_int(obj2));
11538 if (SWIG_arg_fail(3)) SWIG_fail;
11539 }
11540 if (obj3) {
11541 {
11542 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11543 if (SWIG_arg_fail(4)) SWIG_fail;
11544 }
11545 }
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11549
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11563 PyObject *resultobj;
11564 wxImage *arg1 = (wxImage *) 0 ;
11565 byte *arg2 = (byte *) 0 ;
11566 byte *arg3 = (byte *) 0 ;
11567 byte *arg4 = (byte *) 0 ;
11568 byte arg5 = (byte) 0 ;
11569 byte arg6 = (byte) 0 ;
11570 byte arg7 = (byte) 0 ;
11571 bool result;
11572 byte temp2 ;
11573 int res2 = 0 ;
11574 byte temp3 ;
11575 int res3 = 0 ;
11576 byte temp4 ;
11577 int res4 = 0 ;
11578 PyObject * obj0 = 0 ;
11579 PyObject * obj1 = 0 ;
11580 PyObject * obj2 = 0 ;
11581 PyObject * obj3 = 0 ;
11582 char *kwnames[] = {
11583 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11584 };
11585
11586 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11587 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11588 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11591 if (SWIG_arg_fail(1)) SWIG_fail;
11592 if (obj1) {
11593 {
11594 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11595 if (SWIG_arg_fail(5)) SWIG_fail;
11596 }
11597 }
11598 if (obj2) {
11599 {
11600 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11601 if (SWIG_arg_fail(6)) SWIG_fail;
11602 }
11603 }
11604 if (obj3) {
11605 {
11606 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11607 if (SWIG_arg_fail(7)) SWIG_fail;
11608 }
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11613
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 {
11618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11619 }
11620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11621 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11623 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11624 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11625 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj;
11634 wxImage *arg1 = (wxImage *) 0 ;
11635 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11636 bool result;
11637 PyObject * obj0 = 0 ;
11638 PyObject * obj1 = 0 ;
11639 char *kwnames[] = {
11640 (char *) "self",(char *) "threshold", NULL
11641 };
11642
11643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11645 if (SWIG_arg_fail(1)) SWIG_fail;
11646 if (obj1) {
11647 {
11648 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11649 if (SWIG_arg_fail(2)) SWIG_fail;
11650 }
11651 }
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11655
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11661 }
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11669 PyObject *resultobj;
11670 wxImage *arg1 = (wxImage *) 0 ;
11671 unsigned char arg2 ;
11672 unsigned char arg3 ;
11673 unsigned char arg4 ;
11674 bool result;
11675 PyObject * obj0 = 0 ;
11676 PyObject * obj1 = 0 ;
11677 PyObject * obj2 = 0 ;
11678 PyObject * obj3 = 0 ;
11679 char *kwnames[] = {
11680 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11681 };
11682
11683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11685 if (SWIG_arg_fail(1)) SWIG_fail;
11686 {
11687 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11688 if (SWIG_arg_fail(2)) SWIG_fail;
11689 }
11690 {
11691 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11692 if (SWIG_arg_fail(3)) SWIG_fail;
11693 }
11694 {
11695 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11696 if (SWIG_arg_fail(4)) SWIG_fail;
11697 }
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11701
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 {
11706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11707 }
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11715 PyObject *resultobj;
11716 wxImage *arg1 = (wxImage *) 0 ;
11717 wxImage *arg2 = 0 ;
11718 byte arg3 ;
11719 byte arg4 ;
11720 byte arg5 ;
11721 bool result;
11722 PyObject * obj0 = 0 ;
11723 PyObject * obj1 = 0 ;
11724 PyObject * obj2 = 0 ;
11725 PyObject * obj3 = 0 ;
11726 PyObject * obj4 = 0 ;
11727 char *kwnames[] = {
11728 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11729 };
11730
11731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11733 if (SWIG_arg_fail(1)) SWIG_fail;
11734 {
11735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11736 if (SWIG_arg_fail(2)) SWIG_fail;
11737 if (arg2 == NULL) {
11738 SWIG_null_ref("wxImage");
11739 }
11740 if (SWIG_arg_fail(2)) SWIG_fail;
11741 }
11742 {
11743 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11744 if (SWIG_arg_fail(3)) SWIG_fail;
11745 }
11746 {
11747 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11748 if (SWIG_arg_fail(4)) SWIG_fail;
11749 }
11750 {
11751 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11752 if (SWIG_arg_fail(5)) SWIG_fail;
11753 }
11754 {
11755 PyThreadState* __tstate = wxPyBeginAllowThreads();
11756 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11757
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 {
11762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11763 }
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11771 PyObject *resultobj;
11772 wxString *arg1 = 0 ;
11773 bool result;
11774 bool temp1 = false ;
11775 PyObject * obj0 = 0 ;
11776 char *kwnames[] = {
11777 (char *) "name", NULL
11778 };
11779
11780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11781 {
11782 arg1 = wxString_in_helper(obj0);
11783 if (arg1 == NULL) SWIG_fail;
11784 temp1 = true;
11785 }
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11789
11790 wxPyEndAllowThreads(__tstate);
11791 if (PyErr_Occurred()) SWIG_fail;
11792 }
11793 {
11794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11795 }
11796 {
11797 if (temp1)
11798 delete arg1;
11799 }
11800 return resultobj;
11801 fail:
11802 {
11803 if (temp1)
11804 delete arg1;
11805 }
11806 return NULL;
11807 }
11808
11809
11810 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj;
11812 wxString *arg1 = 0 ;
11813 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11814 int result;
11815 bool temp1 = false ;
11816 PyObject * obj0 = 0 ;
11817 PyObject * obj1 = 0 ;
11818 char *kwnames[] = {
11819 (char *) "name",(char *) "type", NULL
11820 };
11821
11822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11823 {
11824 arg1 = wxString_in_helper(obj0);
11825 if (arg1 == NULL) SWIG_fail;
11826 temp1 = true;
11827 }
11828 if (obj1) {
11829 {
11830 arg2 = (long)(SWIG_As_long(obj1));
11831 if (SWIG_arg_fail(2)) SWIG_fail;
11832 }
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11837
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 {
11842 resultobj = SWIG_From_int((int)(result));
11843 }
11844 {
11845 if (temp1)
11846 delete arg1;
11847 }
11848 return resultobj;
11849 fail:
11850 {
11851 if (temp1)
11852 delete arg1;
11853 }
11854 return NULL;
11855 }
11856
11857
11858 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11859 PyObject *resultobj;
11860 wxImage *arg1 = (wxImage *) 0 ;
11861 wxString *arg2 = 0 ;
11862 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11863 int arg4 = (int) -1 ;
11864 bool result;
11865 bool temp2 = false ;
11866 PyObject * obj0 = 0 ;
11867 PyObject * obj1 = 0 ;
11868 PyObject * obj2 = 0 ;
11869 PyObject * obj3 = 0 ;
11870 char *kwnames[] = {
11871 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11872 };
11873
11874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11876 if (SWIG_arg_fail(1)) SWIG_fail;
11877 {
11878 arg2 = wxString_in_helper(obj1);
11879 if (arg2 == NULL) SWIG_fail;
11880 temp2 = true;
11881 }
11882 if (obj2) {
11883 {
11884 arg3 = (long)(SWIG_As_long(obj2));
11885 if (SWIG_arg_fail(3)) SWIG_fail;
11886 }
11887 }
11888 if (obj3) {
11889 {
11890 arg4 = (int)(SWIG_As_int(obj3));
11891 if (SWIG_arg_fail(4)) SWIG_fail;
11892 }
11893 }
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11897
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11903 }
11904 {
11905 if (temp2)
11906 delete arg2;
11907 }
11908 return resultobj;
11909 fail:
11910 {
11911 if (temp2)
11912 delete arg2;
11913 }
11914 return NULL;
11915 }
11916
11917
11918 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11919 PyObject *resultobj;
11920 wxImage *arg1 = (wxImage *) 0 ;
11921 wxString *arg2 = 0 ;
11922 wxString *arg3 = 0 ;
11923 int arg4 = (int) -1 ;
11924 bool result;
11925 bool temp2 = false ;
11926 bool temp3 = false ;
11927 PyObject * obj0 = 0 ;
11928 PyObject * obj1 = 0 ;
11929 PyObject * obj2 = 0 ;
11930 PyObject * obj3 = 0 ;
11931 char *kwnames[] = {
11932 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11933 };
11934
11935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11937 if (SWIG_arg_fail(1)) SWIG_fail;
11938 {
11939 arg2 = wxString_in_helper(obj1);
11940 if (arg2 == NULL) SWIG_fail;
11941 temp2 = true;
11942 }
11943 {
11944 arg3 = wxString_in_helper(obj2);
11945 if (arg3 == NULL) SWIG_fail;
11946 temp3 = true;
11947 }
11948 if (obj3) {
11949 {
11950 arg4 = (int)(SWIG_As_int(obj3));
11951 if (SWIG_arg_fail(4)) SWIG_fail;
11952 }
11953 }
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11957
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 {
11962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11963 }
11964 {
11965 if (temp2)
11966 delete arg2;
11967 }
11968 {
11969 if (temp3)
11970 delete arg3;
11971 }
11972 return resultobj;
11973 fail:
11974 {
11975 if (temp2)
11976 delete arg2;
11977 }
11978 {
11979 if (temp3)
11980 delete arg3;
11981 }
11982 return NULL;
11983 }
11984
11985
11986 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11987 PyObject *resultobj;
11988 wxImage *arg1 = (wxImage *) 0 ;
11989 wxString *arg2 = 0 ;
11990 int arg3 ;
11991 bool result;
11992 bool temp2 = false ;
11993 PyObject * obj0 = 0 ;
11994 PyObject * obj1 = 0 ;
11995 PyObject * obj2 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self",(char *) "name",(char *) "type", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 arg2 = wxString_in_helper(obj1);
12005 if (arg2 == NULL) SWIG_fail;
12006 temp2 = true;
12007 }
12008 {
12009 arg3 = (int)(SWIG_As_int(obj2));
12010 if (SWIG_arg_fail(3)) SWIG_fail;
12011 }
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12015
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 {
12020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12021 }
12022 {
12023 if (temp2)
12024 delete arg2;
12025 }
12026 return resultobj;
12027 fail:
12028 {
12029 if (temp2)
12030 delete arg2;
12031 }
12032 return NULL;
12033 }
12034
12035
12036 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12037 PyObject *resultobj;
12038 wxImage *arg1 = (wxImage *) 0 ;
12039 wxString *arg2 = 0 ;
12040 wxString *arg3 = 0 ;
12041 bool result;
12042 bool temp2 = false ;
12043 bool temp3 = false ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 PyObject * obj2 = 0 ;
12047 char *kwnames[] = {
12048 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12049 };
12050
12051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12053 if (SWIG_arg_fail(1)) SWIG_fail;
12054 {
12055 arg2 = wxString_in_helper(obj1);
12056 if (arg2 == NULL) SWIG_fail;
12057 temp2 = true;
12058 }
12059 {
12060 arg3 = wxString_in_helper(obj2);
12061 if (arg3 == NULL) SWIG_fail;
12062 temp3 = true;
12063 }
12064 {
12065 PyThreadState* __tstate = wxPyBeginAllowThreads();
12066 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12067
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 {
12072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12073 }
12074 {
12075 if (temp2)
12076 delete arg2;
12077 }
12078 {
12079 if (temp3)
12080 delete arg3;
12081 }
12082 return resultobj;
12083 fail:
12084 {
12085 if (temp2)
12086 delete arg2;
12087 }
12088 {
12089 if (temp3)
12090 delete arg3;
12091 }
12092 return NULL;
12093 }
12094
12095
12096 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12097 PyObject *resultobj;
12098 wxInputStream *arg1 = 0 ;
12099 bool result;
12100 wxPyInputStream *temp1 ;
12101 bool created1 ;
12102 PyObject * obj0 = 0 ;
12103 char *kwnames[] = {
12104 (char *) "stream", NULL
12105 };
12106
12107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12108 {
12109 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12110 arg1 = temp1->m_wxis;
12111 created1 = false;
12112 } else {
12113 PyErr_Clear(); // clear the failure of the wxPyConvert above
12114 arg1 = wxPyCBInputStream_create(obj0, false);
12115 if (arg1 == NULL) {
12116 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12117 SWIG_fail;
12118 }
12119 created1 = true;
12120 }
12121 }
12122 {
12123 PyThreadState* __tstate = wxPyBeginAllowThreads();
12124 result = (bool)wxImage::CanRead(*arg1);
12125
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 {
12130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12131 }
12132 {
12133 if (created1) delete arg1;
12134 }
12135 return resultobj;
12136 fail:
12137 {
12138 if (created1) delete arg1;
12139 }
12140 return NULL;
12141 }
12142
12143
12144 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12145 PyObject *resultobj;
12146 wxImage *arg1 = (wxImage *) 0 ;
12147 wxInputStream *arg2 = 0 ;
12148 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12149 int arg4 = (int) -1 ;
12150 bool result;
12151 wxPyInputStream *temp2 ;
12152 bool created2 ;
12153 PyObject * obj0 = 0 ;
12154 PyObject * obj1 = 0 ;
12155 PyObject * obj2 = 0 ;
12156 PyObject * obj3 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12166 arg2 = temp2->m_wxis;
12167 created2 = false;
12168 } else {
12169 PyErr_Clear(); // clear the failure of the wxPyConvert above
12170 arg2 = wxPyCBInputStream_create(obj1, false);
12171 if (arg2 == NULL) {
12172 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12173 SWIG_fail;
12174 }
12175 created2 = true;
12176 }
12177 }
12178 if (obj2) {
12179 {
12180 arg3 = (long)(SWIG_As_long(obj2));
12181 if (SWIG_arg_fail(3)) SWIG_fail;
12182 }
12183 }
12184 if (obj3) {
12185 {
12186 arg4 = (int)(SWIG_As_int(obj3));
12187 if (SWIG_arg_fail(4)) SWIG_fail;
12188 }
12189 }
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12193
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 {
12198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12199 }
12200 {
12201 if (created2) delete arg2;
12202 }
12203 return resultobj;
12204 fail:
12205 {
12206 if (created2) delete arg2;
12207 }
12208 return NULL;
12209 }
12210
12211
12212 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12213 PyObject *resultobj;
12214 wxImage *arg1 = (wxImage *) 0 ;
12215 wxInputStream *arg2 = 0 ;
12216 wxString *arg3 = 0 ;
12217 int arg4 = (int) -1 ;
12218 bool result;
12219 wxPyInputStream *temp2 ;
12220 bool created2 ;
12221 bool temp3 = false ;
12222 PyObject * obj0 = 0 ;
12223 PyObject * obj1 = 0 ;
12224 PyObject * obj2 = 0 ;
12225 PyObject * obj3 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12232 if (SWIG_arg_fail(1)) SWIG_fail;
12233 {
12234 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12235 arg2 = temp2->m_wxis;
12236 created2 = false;
12237 } else {
12238 PyErr_Clear(); // clear the failure of the wxPyConvert above
12239 arg2 = wxPyCBInputStream_create(obj1, false);
12240 if (arg2 == NULL) {
12241 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12242 SWIG_fail;
12243 }
12244 created2 = true;
12245 }
12246 }
12247 {
12248 arg3 = wxString_in_helper(obj2);
12249 if (arg3 == NULL) SWIG_fail;
12250 temp3 = true;
12251 }
12252 if (obj3) {
12253 {
12254 arg4 = (int)(SWIG_As_int(obj3));
12255 if (SWIG_arg_fail(4)) SWIG_fail;
12256 }
12257 }
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12267 }
12268 {
12269 if (created2) delete arg2;
12270 }
12271 {
12272 if (temp3)
12273 delete arg3;
12274 }
12275 return resultobj;
12276 fail:
12277 {
12278 if (created2) delete arg2;
12279 }
12280 {
12281 if (temp3)
12282 delete arg3;
12283 }
12284 return NULL;
12285 }
12286
12287
12288 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12289 PyObject *resultobj;
12290 wxImage *arg1 = (wxImage *) 0 ;
12291 bool result;
12292 PyObject * obj0 = 0 ;
12293 char *kwnames[] = {
12294 (char *) "self", NULL
12295 };
12296
12297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12299 if (SWIG_arg_fail(1)) SWIG_fail;
12300 {
12301 PyThreadState* __tstate = wxPyBeginAllowThreads();
12302 result = (bool)(arg1)->Ok();
12303
12304 wxPyEndAllowThreads(__tstate);
12305 if (PyErr_Occurred()) SWIG_fail;
12306 }
12307 {
12308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12309 }
12310 return resultobj;
12311 fail:
12312 return NULL;
12313 }
12314
12315
12316 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12317 PyObject *resultobj;
12318 wxImage *arg1 = (wxImage *) 0 ;
12319 int result;
12320 PyObject * obj0 = 0 ;
12321 char *kwnames[] = {
12322 (char *) "self", NULL
12323 };
12324
12325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12327 if (SWIG_arg_fail(1)) SWIG_fail;
12328 {
12329 PyThreadState* __tstate = wxPyBeginAllowThreads();
12330 result = (int)(arg1)->GetWidth();
12331
12332 wxPyEndAllowThreads(__tstate);
12333 if (PyErr_Occurred()) SWIG_fail;
12334 }
12335 {
12336 resultobj = SWIG_From_int((int)(result));
12337 }
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj;
12346 wxImage *arg1 = (wxImage *) 0 ;
12347 int result;
12348 PyObject * obj0 = 0 ;
12349 char *kwnames[] = {
12350 (char *) "self", NULL
12351 };
12352
12353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12355 if (SWIG_arg_fail(1)) SWIG_fail;
12356 {
12357 PyThreadState* __tstate = wxPyBeginAllowThreads();
12358 result = (int)(arg1)->GetHeight();
12359
12360 wxPyEndAllowThreads(__tstate);
12361 if (PyErr_Occurred()) SWIG_fail;
12362 }
12363 {
12364 resultobj = SWIG_From_int((int)(result));
12365 }
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12373 PyObject *resultobj;
12374 wxImage *arg1 = (wxImage *) 0 ;
12375 wxSize result;
12376 PyObject * obj0 = 0 ;
12377 char *kwnames[] = {
12378 (char *) "self", NULL
12379 };
12380
12381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12383 if (SWIG_arg_fail(1)) SWIG_fail;
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = wxImage_GetSize(arg1);
12387
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 {
12392 wxSize * resultptr;
12393 resultptr = new wxSize((wxSize &)(result));
12394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12395 }
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj;
12404 wxImage *arg1 = (wxImage *) 0 ;
12405 wxRect *arg2 = 0 ;
12406 SwigValueWrapper<wxImage > result;
12407 wxRect temp2 ;
12408 PyObject * obj0 = 0 ;
12409 PyObject * obj1 = 0 ;
12410 char *kwnames[] = {
12411 (char *) "self",(char *) "rect", NULL
12412 };
12413
12414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12416 if (SWIG_arg_fail(1)) SWIG_fail;
12417 {
12418 arg2 = &temp2;
12419 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12420 }
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12424
12425 wxPyEndAllowThreads(__tstate);
12426 if (PyErr_Occurred()) SWIG_fail;
12427 }
12428 {
12429 wxImage * resultptr;
12430 resultptr = new wxImage((wxImage &)(result));
12431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12432 }
12433 return resultobj;
12434 fail:
12435 return NULL;
12436 }
12437
12438
12439 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12440 PyObject *resultobj;
12441 wxImage *arg1 = (wxImage *) 0 ;
12442 wxSize *arg2 = 0 ;
12443 wxPoint *arg3 = 0 ;
12444 int arg4 = (int) -1 ;
12445 int arg5 = (int) -1 ;
12446 int arg6 = (int) -1 ;
12447 SwigValueWrapper<wxImage > result;
12448 wxSize temp2 ;
12449 wxPoint temp3 ;
12450 PyObject * obj0 = 0 ;
12451 PyObject * obj1 = 0 ;
12452 PyObject * obj2 = 0 ;
12453 PyObject * obj3 = 0 ;
12454 PyObject * obj4 = 0 ;
12455 PyObject * obj5 = 0 ;
12456 char *kwnames[] = {
12457 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12458 };
12459
12460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12462 if (SWIG_arg_fail(1)) SWIG_fail;
12463 {
12464 arg2 = &temp2;
12465 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12466 }
12467 {
12468 arg3 = &temp3;
12469 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12470 }
12471 if (obj3) {
12472 {
12473 arg4 = (int)(SWIG_As_int(obj3));
12474 if (SWIG_arg_fail(4)) SWIG_fail;
12475 }
12476 }
12477 if (obj4) {
12478 {
12479 arg5 = (int)(SWIG_As_int(obj4));
12480 if (SWIG_arg_fail(5)) SWIG_fail;
12481 }
12482 }
12483 if (obj5) {
12484 {
12485 arg6 = (int)(SWIG_As_int(obj5));
12486 if (SWIG_arg_fail(6)) SWIG_fail;
12487 }
12488 }
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12492
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 {
12497 wxImage * resultptr;
12498 resultptr = new wxImage((wxImage &)(result));
12499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12500 }
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj;
12509 wxImage *arg1 = (wxImage *) 0 ;
12510 SwigValueWrapper<wxImage > result;
12511 PyObject * obj0 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = (arg1)->Copy();
12522
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 {
12527 wxImage * resultptr;
12528 resultptr = new wxImage((wxImage &)(result));
12529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12530 }
12531 return resultobj;
12532 fail:
12533 return NULL;
12534 }
12535
12536
12537 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj;
12539 wxImage *arg1 = (wxImage *) 0 ;
12540 wxImage *arg2 = 0 ;
12541 int arg3 ;
12542 int arg4 ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 PyObject * obj2 = 0 ;
12546 PyObject * obj3 = 0 ;
12547 char *kwnames[] = {
12548 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12549 };
12550
12551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12553 if (SWIG_arg_fail(1)) SWIG_fail;
12554 {
12555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(2)) SWIG_fail;
12557 if (arg2 == NULL) {
12558 SWIG_null_ref("wxImage");
12559 }
12560 if (SWIG_arg_fail(2)) SWIG_fail;
12561 }
12562 {
12563 arg3 = (int)(SWIG_As_int(obj2));
12564 if (SWIG_arg_fail(3)) SWIG_fail;
12565 }
12566 {
12567 arg4 = (int)(SWIG_As_int(obj3));
12568 if (SWIG_arg_fail(4)) SWIG_fail;
12569 }
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12573
12574 wxPyEndAllowThreads(__tstate);
12575 if (PyErr_Occurred()) SWIG_fail;
12576 }
12577 Py_INCREF(Py_None); resultobj = Py_None;
12578 return resultobj;
12579 fail:
12580 return NULL;
12581 }
12582
12583
12584 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj;
12586 wxImage *arg1 = (wxImage *) 0 ;
12587 PyObject *result;
12588 PyObject * obj0 = 0 ;
12589 char *kwnames[] = {
12590 (char *) "self", NULL
12591 };
12592
12593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12595 if (SWIG_arg_fail(1)) SWIG_fail;
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 result = (PyObject *)wxImage_GetData(arg1);
12599
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 resultobj = result;
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxImage *arg1 = (wxImage *) 0 ;
12613 buffer arg2 ;
12614 int arg3 ;
12615 PyObject * obj0 = 0 ;
12616 PyObject * obj1 = 0 ;
12617 char *kwnames[] = {
12618 (char *) "self",(char *) "data", NULL
12619 };
12620
12621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12623 if (SWIG_arg_fail(1)) SWIG_fail;
12624 {
12625 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12626 }
12627 {
12628 PyThreadState* __tstate = wxPyBeginAllowThreads();
12629 wxImage_SetData(arg1,arg2,arg3);
12630
12631 wxPyEndAllowThreads(__tstate);
12632 if (PyErr_Occurred()) SWIG_fail;
12633 }
12634 Py_INCREF(Py_None); resultobj = Py_None;
12635 return resultobj;
12636 fail:
12637 return NULL;
12638 }
12639
12640
12641 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj;
12643 wxImage *arg1 = (wxImage *) 0 ;
12644 PyObject *result;
12645 PyObject * obj0 = 0 ;
12646 char *kwnames[] = {
12647 (char *) "self", NULL
12648 };
12649
12650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12652 if (SWIG_arg_fail(1)) SWIG_fail;
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12656
12657 wxPyEndAllowThreads(__tstate);
12658 if (PyErr_Occurred()) SWIG_fail;
12659 }
12660 resultobj = result;
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12668 PyObject *resultobj;
12669 wxImage *arg1 = (wxImage *) 0 ;
12670 buffer arg2 ;
12671 int arg3 ;
12672 PyObject * obj0 = 0 ;
12673 PyObject * obj1 = 0 ;
12674 char *kwnames[] = {
12675 (char *) "self",(char *) "data", NULL
12676 };
12677
12678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12680 if (SWIG_arg_fail(1)) SWIG_fail;
12681 {
12682 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12683 }
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 wxImage_SetDataBuffer(arg1,arg2,arg3);
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 Py_INCREF(Py_None); resultobj = Py_None;
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj;
12700 wxImage *arg1 = (wxImage *) 0 ;
12701 PyObject *result;
12702 PyObject * obj0 = 0 ;
12703 char *kwnames[] = {
12704 (char *) "self", NULL
12705 };
12706
12707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(1)) SWIG_fail;
12710 {
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 result = (PyObject *)wxImage_GetAlphaData(arg1);
12713
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 resultobj = result;
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12725 PyObject *resultobj;
12726 wxImage *arg1 = (wxImage *) 0 ;
12727 buffer arg2 ;
12728 int arg3 ;
12729 PyObject * obj0 = 0 ;
12730 PyObject * obj1 = 0 ;
12731 char *kwnames[] = {
12732 (char *) "self",(char *) "alpha", NULL
12733 };
12734
12735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12737 if (SWIG_arg_fail(1)) SWIG_fail;
12738 {
12739 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12740 }
12741 {
12742 PyThreadState* __tstate = wxPyBeginAllowThreads();
12743 wxImage_SetAlphaData(arg1,arg2,arg3);
12744
12745 wxPyEndAllowThreads(__tstate);
12746 if (PyErr_Occurred()) SWIG_fail;
12747 }
12748 Py_INCREF(Py_None); resultobj = Py_None;
12749 return resultobj;
12750 fail:
12751 return NULL;
12752 }
12753
12754
12755 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12756 PyObject *resultobj;
12757 wxImage *arg1 = (wxImage *) 0 ;
12758 PyObject *result;
12759 PyObject * obj0 = 0 ;
12760 char *kwnames[] = {
12761 (char *) "self", NULL
12762 };
12763
12764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(1)) SWIG_fail;
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12770
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = result;
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj;
12783 wxImage *arg1 = (wxImage *) 0 ;
12784 buffer arg2 ;
12785 int arg3 ;
12786 PyObject * obj0 = 0 ;
12787 PyObject * obj1 = 0 ;
12788 char *kwnames[] = {
12789 (char *) "self",(char *) "alpha", NULL
12790 };
12791
12792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12794 if (SWIG_arg_fail(1)) SWIG_fail;
12795 {
12796 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12797 }
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12801
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 Py_INCREF(Py_None); resultobj = Py_None;
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxImage *arg1 = (wxImage *) 0 ;
12815 unsigned char arg2 ;
12816 unsigned char arg3 ;
12817 unsigned char arg4 ;
12818 PyObject * obj0 = 0 ;
12819 PyObject * obj1 = 0 ;
12820 PyObject * obj2 = 0 ;
12821 PyObject * obj3 = 0 ;
12822 char *kwnames[] = {
12823 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12824 };
12825
12826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12828 if (SWIG_arg_fail(1)) SWIG_fail;
12829 {
12830 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12831 if (SWIG_arg_fail(2)) SWIG_fail;
12832 }
12833 {
12834 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12835 if (SWIG_arg_fail(3)) SWIG_fail;
12836 }
12837 {
12838 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12839 if (SWIG_arg_fail(4)) SWIG_fail;
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 (arg1)->SetMaskColour(arg2,arg3,arg4);
12844
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 Py_INCREF(Py_None); resultobj = Py_None;
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12856 PyObject *resultobj;
12857 wxImage *arg1 = (wxImage *) 0 ;
12858 unsigned char *arg2 = (unsigned char *) 0 ;
12859 unsigned char *arg3 = (unsigned char *) 0 ;
12860 unsigned char *arg4 = (unsigned char *) 0 ;
12861 unsigned char temp2 ;
12862 int res2 = 0 ;
12863 unsigned char temp3 ;
12864 int res3 = 0 ;
12865 unsigned char temp4 ;
12866 int res4 = 0 ;
12867 PyObject * obj0 = 0 ;
12868 char *kwnames[] = {
12869 (char *) "self", NULL
12870 };
12871
12872 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12873 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12874 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12877 if (SWIG_arg_fail(1)) SWIG_fail;
12878 {
12879 PyThreadState* __tstate = wxPyBeginAllowThreads();
12880 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12881
12882 wxPyEndAllowThreads(__tstate);
12883 if (PyErr_Occurred()) SWIG_fail;
12884 }
12885 Py_INCREF(Py_None); resultobj = Py_None;
12886 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12887 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12888 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12889 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12890 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12891 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj;
12900 wxImage *arg1 = (wxImage *) 0 ;
12901 unsigned char result;
12902 PyObject * obj0 = 0 ;
12903 char *kwnames[] = {
12904 (char *) "self", NULL
12905 };
12906
12907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12909 if (SWIG_arg_fail(1)) SWIG_fail;
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = (unsigned char)(arg1)->GetMaskRed();
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 {
12918 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12919 }
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj;
12928 wxImage *arg1 = (wxImage *) 0 ;
12929 unsigned char result;
12930 PyObject * obj0 = 0 ;
12931 char *kwnames[] = {
12932 (char *) "self", NULL
12933 };
12934
12935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12937 if (SWIG_arg_fail(1)) SWIG_fail;
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 result = (unsigned char)(arg1)->GetMaskGreen();
12941
12942 wxPyEndAllowThreads(__tstate);
12943 if (PyErr_Occurred()) SWIG_fail;
12944 }
12945 {
12946 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12947 }
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12955 PyObject *resultobj;
12956 wxImage *arg1 = (wxImage *) 0 ;
12957 unsigned char result;
12958 PyObject * obj0 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = (unsigned char)(arg1)->GetMaskBlue();
12969
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 {
12974 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12975 }
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12983 PyObject *resultobj;
12984 wxImage *arg1 = (wxImage *) 0 ;
12985 bool arg2 = (bool) true ;
12986 PyObject * obj0 = 0 ;
12987 PyObject * obj1 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self",(char *) "mask", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 if (obj1) {
12996 {
12997 arg2 = (bool)(SWIG_As_bool(obj1));
12998 if (SWIG_arg_fail(2)) SWIG_fail;
12999 }
13000 }
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 (arg1)->SetMask(arg2);
13004
13005 wxPyEndAllowThreads(__tstate);
13006 if (PyErr_Occurred()) SWIG_fail;
13007 }
13008 Py_INCREF(Py_None); resultobj = Py_None;
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj;
13017 wxImage *arg1 = (wxImage *) 0 ;
13018 bool result;
13019 PyObject * obj0 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = (bool)(arg1)->HasMask();
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 {
13035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13036 }
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj;
13045 wxImage *arg1 = (wxImage *) 0 ;
13046 double arg2 ;
13047 wxPoint *arg3 = 0 ;
13048 bool arg4 = (bool) true ;
13049 wxPoint *arg5 = (wxPoint *) NULL ;
13050 SwigValueWrapper<wxImage > result;
13051 wxPoint temp3 ;
13052 PyObject * obj0 = 0 ;
13053 PyObject * obj1 = 0 ;
13054 PyObject * obj2 = 0 ;
13055 PyObject * obj3 = 0 ;
13056 PyObject * obj4 = 0 ;
13057 char *kwnames[] = {
13058 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13059 };
13060
13061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13063 if (SWIG_arg_fail(1)) SWIG_fail;
13064 {
13065 arg2 = (double)(SWIG_As_double(obj1));
13066 if (SWIG_arg_fail(2)) SWIG_fail;
13067 }
13068 {
13069 arg3 = &temp3;
13070 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13071 }
13072 if (obj3) {
13073 {
13074 arg4 = (bool)(SWIG_As_bool(obj3));
13075 if (SWIG_arg_fail(4)) SWIG_fail;
13076 }
13077 }
13078 if (obj4) {
13079 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(5)) SWIG_fail;
13081 }
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13085
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 {
13090 wxImage * resultptr;
13091 resultptr = new wxImage((wxImage &)(result));
13092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13093 }
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj;
13102 wxImage *arg1 = (wxImage *) 0 ;
13103 bool arg2 = (bool) true ;
13104 SwigValueWrapper<wxImage > result;
13105 PyObject * obj0 = 0 ;
13106 PyObject * obj1 = 0 ;
13107 char *kwnames[] = {
13108 (char *) "self",(char *) "clockwise", NULL
13109 };
13110
13111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(1)) SWIG_fail;
13114 if (obj1) {
13115 {
13116 arg2 = (bool)(SWIG_As_bool(obj1));
13117 if (SWIG_arg_fail(2)) SWIG_fail;
13118 }
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (arg1)->Rotate90(arg2);
13123
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 {
13128 wxImage * resultptr;
13129 resultptr = new wxImage((wxImage &)(result));
13130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13131 }
13132 return resultobj;
13133 fail:
13134 return NULL;
13135 }
13136
13137
13138 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13139 PyObject *resultobj;
13140 wxImage *arg1 = (wxImage *) 0 ;
13141 bool arg2 = (bool) true ;
13142 SwigValueWrapper<wxImage > result;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char *kwnames[] = {
13146 (char *) "self",(char *) "horizontally", NULL
13147 };
13148
13149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13151 if (SWIG_arg_fail(1)) SWIG_fail;
13152 if (obj1) {
13153 {
13154 arg2 = (bool)(SWIG_As_bool(obj1));
13155 if (SWIG_arg_fail(2)) SWIG_fail;
13156 }
13157 }
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 result = (arg1)->Mirror(arg2);
13161
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 {
13166 wxImage * resultptr;
13167 resultptr = new wxImage((wxImage &)(result));
13168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13169 }
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj;
13178 wxImage *arg1 = (wxImage *) 0 ;
13179 unsigned char arg2 ;
13180 unsigned char arg3 ;
13181 unsigned char arg4 ;
13182 unsigned char arg5 ;
13183 unsigned char arg6 ;
13184 unsigned char arg7 ;
13185 PyObject * obj0 = 0 ;
13186 PyObject * obj1 = 0 ;
13187 PyObject * obj2 = 0 ;
13188 PyObject * obj3 = 0 ;
13189 PyObject * obj4 = 0 ;
13190 PyObject * obj5 = 0 ;
13191 PyObject * obj6 = 0 ;
13192 char *kwnames[] = {
13193 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13194 };
13195
13196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13198 if (SWIG_arg_fail(1)) SWIG_fail;
13199 {
13200 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13201 if (SWIG_arg_fail(2)) SWIG_fail;
13202 }
13203 {
13204 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13205 if (SWIG_arg_fail(3)) SWIG_fail;
13206 }
13207 {
13208 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13209 if (SWIG_arg_fail(4)) SWIG_fail;
13210 }
13211 {
13212 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13213 if (SWIG_arg_fail(5)) SWIG_fail;
13214 }
13215 {
13216 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13217 if (SWIG_arg_fail(6)) SWIG_fail;
13218 }
13219 {
13220 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13221 if (SWIG_arg_fail(7)) SWIG_fail;
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 Py_INCREF(Py_None); resultobj = Py_None;
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13238 PyObject *resultobj;
13239 wxImage *arg1 = (wxImage *) 0 ;
13240 unsigned char arg2 ;
13241 unsigned char arg3 ;
13242 unsigned char arg4 ;
13243 SwigValueWrapper<wxImage > result;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 PyObject * obj2 = 0 ;
13247 PyObject * obj3 = 0 ;
13248 char *kwnames[] = {
13249 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13250 };
13251
13252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13254 if (SWIG_arg_fail(1)) SWIG_fail;
13255 {
13256 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13257 if (SWIG_arg_fail(2)) SWIG_fail;
13258 }
13259 {
13260 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13261 if (SWIG_arg_fail(3)) SWIG_fail;
13262 }
13263 {
13264 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13265 if (SWIG_arg_fail(4)) SWIG_fail;
13266 }
13267 {
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13270
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 {
13275 wxImage * resultptr;
13276 resultptr = new wxImage((wxImage &)(result));
13277 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13278 }
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj;
13287 wxImage *arg1 = (wxImage *) 0 ;
13288 wxString *arg2 = 0 ;
13289 wxString *arg3 = 0 ;
13290 bool temp2 = false ;
13291 bool temp3 = false ;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 PyObject * obj2 = 0 ;
13295 char *kwnames[] = {
13296 (char *) "self",(char *) "name",(char *) "value", NULL
13297 };
13298
13299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13301 if (SWIG_arg_fail(1)) SWIG_fail;
13302 {
13303 arg2 = wxString_in_helper(obj1);
13304 if (arg2 == NULL) SWIG_fail;
13305 temp2 = true;
13306 }
13307 {
13308 arg3 = wxString_in_helper(obj2);
13309 if (arg3 == NULL) SWIG_fail;
13310 temp3 = true;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13315
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 Py_INCREF(Py_None); resultobj = Py_None;
13320 {
13321 if (temp2)
13322 delete arg2;
13323 }
13324 {
13325 if (temp3)
13326 delete arg3;
13327 }
13328 return resultobj;
13329 fail:
13330 {
13331 if (temp2)
13332 delete arg2;
13333 }
13334 {
13335 if (temp3)
13336 delete arg3;
13337 }
13338 return NULL;
13339 }
13340
13341
13342 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj;
13344 wxImage *arg1 = (wxImage *) 0 ;
13345 wxString *arg2 = 0 ;
13346 int arg3 ;
13347 bool temp2 = false ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 PyObject * obj2 = 0 ;
13351 char *kwnames[] = {
13352 (char *) "self",(char *) "name",(char *) "value", NULL
13353 };
13354
13355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13357 if (SWIG_arg_fail(1)) SWIG_fail;
13358 {
13359 arg2 = wxString_in_helper(obj1);
13360 if (arg2 == NULL) SWIG_fail;
13361 temp2 = true;
13362 }
13363 {
13364 arg3 = (int)(SWIG_As_int(obj2));
13365 if (SWIG_arg_fail(3)) SWIG_fail;
13366 }
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 (arg1)->SetOption((wxString const &)*arg2,arg3);
13370
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 Py_INCREF(Py_None); resultobj = Py_None;
13375 {
13376 if (temp2)
13377 delete arg2;
13378 }
13379 return resultobj;
13380 fail:
13381 {
13382 if (temp2)
13383 delete arg2;
13384 }
13385 return NULL;
13386 }
13387
13388
13389 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13390 PyObject *resultobj;
13391 wxImage *arg1 = (wxImage *) 0 ;
13392 wxString *arg2 = 0 ;
13393 wxString result;
13394 bool temp2 = false ;
13395 PyObject * obj0 = 0 ;
13396 PyObject * obj1 = 0 ;
13397 char *kwnames[] = {
13398 (char *) "self",(char *) "name", NULL
13399 };
13400
13401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13403 if (SWIG_arg_fail(1)) SWIG_fail;
13404 {
13405 arg2 = wxString_in_helper(obj1);
13406 if (arg2 == NULL) SWIG_fail;
13407 temp2 = true;
13408 }
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 #if wxUSE_UNICODE
13418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13419 #else
13420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13421 #endif
13422 }
13423 {
13424 if (temp2)
13425 delete arg2;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp2)
13431 delete arg2;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj;
13439 wxImage *arg1 = (wxImage *) 0 ;
13440 wxString *arg2 = 0 ;
13441 int result;
13442 bool temp2 = false ;
13443 PyObject * obj0 = 0 ;
13444 PyObject * obj1 = 0 ;
13445 char *kwnames[] = {
13446 (char *) "self",(char *) "name", NULL
13447 };
13448
13449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13451 if (SWIG_arg_fail(1)) SWIG_fail;
13452 {
13453 arg2 = wxString_in_helper(obj1);
13454 if (arg2 == NULL) SWIG_fail;
13455 temp2 = true;
13456 }
13457 {
13458 PyThreadState* __tstate = wxPyBeginAllowThreads();
13459 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13460
13461 wxPyEndAllowThreads(__tstate);
13462 if (PyErr_Occurred()) SWIG_fail;
13463 }
13464 {
13465 resultobj = SWIG_From_int((int)(result));
13466 }
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp2)
13475 delete arg2;
13476 }
13477 return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxImage *arg1 = (wxImage *) 0 ;
13484 wxString *arg2 = 0 ;
13485 bool result;
13486 bool temp2 = false ;
13487 PyObject * obj0 = 0 ;
13488 PyObject * obj1 = 0 ;
13489 char *kwnames[] = {
13490 (char *) "self",(char *) "name", NULL
13491 };
13492
13493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13495 if (SWIG_arg_fail(1)) SWIG_fail;
13496 {
13497 arg2 = wxString_in_helper(obj1);
13498 if (arg2 == NULL) SWIG_fail;
13499 temp2 = true;
13500 }
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13504
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 {
13509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13510 }
13511 {
13512 if (temp2)
13513 delete arg2;
13514 }
13515 return resultobj;
13516 fail:
13517 {
13518 if (temp2)
13519 delete arg2;
13520 }
13521 return NULL;
13522 }
13523
13524
13525 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj;
13527 wxImage *arg1 = (wxImage *) 0 ;
13528 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13529 unsigned long result;
13530 PyObject * obj0 = 0 ;
13531 PyObject * obj1 = 0 ;
13532 char *kwnames[] = {
13533 (char *) "self",(char *) "stopafter", NULL
13534 };
13535
13536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13538 if (SWIG_arg_fail(1)) SWIG_fail;
13539 if (obj1) {
13540 {
13541 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13542 if (SWIG_arg_fail(2)) SWIG_fail;
13543 }
13544 }
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = (unsigned long)(arg1)->CountColours(arg2);
13548
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 {
13553 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13554 }
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13562 PyObject *resultobj;
13563 wxImage *arg1 = (wxImage *) 0 ;
13564 wxImageHistogram *arg2 = 0 ;
13565 unsigned long result;
13566 PyObject * obj0 = 0 ;
13567 PyObject * obj1 = 0 ;
13568 char *kwnames[] = {
13569 (char *) "self",(char *) "h", NULL
13570 };
13571
13572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13574 if (SWIG_arg_fail(1)) SWIG_fail;
13575 {
13576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13577 if (SWIG_arg_fail(2)) SWIG_fail;
13578 if (arg2 == NULL) {
13579 SWIG_null_ref("wxImageHistogram");
13580 }
13581 if (SWIG_arg_fail(2)) SWIG_fail;
13582 }
13583 {
13584 PyThreadState* __tstate = wxPyBeginAllowThreads();
13585 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13586
13587 wxPyEndAllowThreads(__tstate);
13588 if (PyErr_Occurred()) SWIG_fail;
13589 }
13590 {
13591 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13592 }
13593 return resultobj;
13594 fail:
13595 return NULL;
13596 }
13597
13598
13599 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13600 PyObject *resultobj;
13601 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13602 PyObject * obj0 = 0 ;
13603 char *kwnames[] = {
13604 (char *) "handler", NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13609 if (SWIG_arg_fail(1)) SWIG_fail;
13610 {
13611 PyThreadState* __tstate = wxPyBeginAllowThreads();
13612 wxImage::AddHandler(arg1);
13613
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 Py_INCREF(Py_None); resultobj = Py_None;
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj;
13626 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13627 PyObject * obj0 = 0 ;
13628 char *kwnames[] = {
13629 (char *) "handler", NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13634 if (SWIG_arg_fail(1)) SWIG_fail;
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 wxImage::InsertHandler(arg1);
13638
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 Py_INCREF(Py_None); resultobj = Py_None;
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj;
13651 wxString *arg1 = 0 ;
13652 bool result;
13653 bool temp1 = false ;
13654 PyObject * obj0 = 0 ;
13655 char *kwnames[] = {
13656 (char *) "name", NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13660 {
13661 arg1 = wxString_in_helper(obj0);
13662 if (arg1 == NULL) SWIG_fail;
13663 temp1 = true;
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 {
13673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13674 }
13675 {
13676 if (temp1)
13677 delete arg1;
13678 }
13679 return resultobj;
13680 fail:
13681 {
13682 if (temp1)
13683 delete arg1;
13684 }
13685 return NULL;
13686 }
13687
13688
13689 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj;
13691 wxString result;
13692 char *kwnames[] = {
13693 NULL
13694 };
13695
13696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13697 {
13698 PyThreadState* __tstate = wxPyBeginAllowThreads();
13699 result = wxImage::GetImageExtWildcard();
13700
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 {
13705 #if wxUSE_UNICODE
13706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13707 #else
13708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13709 #endif
13710 }
13711 return resultobj;
13712 fail:
13713 return NULL;
13714 }
13715
13716
13717 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj;
13719 wxImage *arg1 = (wxImage *) 0 ;
13720 int arg2 = (int) -1 ;
13721 wxBitmap result;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 char *kwnames[] = {
13725 (char *) "self",(char *) "depth", NULL
13726 };
13727
13728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13730 if (SWIG_arg_fail(1)) SWIG_fail;
13731 if (obj1) {
13732 {
13733 arg2 = (int)(SWIG_As_int(obj1));
13734 if (SWIG_arg_fail(2)) SWIG_fail;
13735 }
13736 }
13737 {
13738 if (!wxPyCheckForApp()) SWIG_fail;
13739 PyThreadState* __tstate = wxPyBeginAllowThreads();
13740 result = wxImage_ConvertToBitmap(arg1,arg2);
13741
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 {
13746 wxBitmap * resultptr;
13747 resultptr = new wxBitmap((wxBitmap &)(result));
13748 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13749 }
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj;
13758 wxImage *arg1 = (wxImage *) 0 ;
13759 unsigned char arg2 ;
13760 unsigned char arg3 ;
13761 unsigned char arg4 ;
13762 wxBitmap result;
13763 PyObject * obj0 = 0 ;
13764 PyObject * obj1 = 0 ;
13765 PyObject * obj2 = 0 ;
13766 PyObject * obj3 = 0 ;
13767 char *kwnames[] = {
13768 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13769 };
13770
13771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13773 if (SWIG_arg_fail(1)) SWIG_fail;
13774 {
13775 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13776 if (SWIG_arg_fail(2)) SWIG_fail;
13777 }
13778 {
13779 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13780 if (SWIG_arg_fail(3)) SWIG_fail;
13781 }
13782 {
13783 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13784 if (SWIG_arg_fail(4)) SWIG_fail;
13785 }
13786 {
13787 if (!wxPyCheckForApp()) SWIG_fail;
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13790
13791 wxPyEndAllowThreads(__tstate);
13792 if (PyErr_Occurred()) SWIG_fail;
13793 }
13794 {
13795 wxBitmap * resultptr;
13796 resultptr = new wxBitmap((wxBitmap &)(result));
13797 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13798 }
13799 return resultobj;
13800 fail:
13801 return NULL;
13802 }
13803
13804
13805 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13806 PyObject *obj;
13807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13808 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13809 Py_INCREF(obj);
13810 return Py_BuildValue((char *)"");
13811 }
13812 static int _wrap_NullImage_set(PyObject *) {
13813 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13814 return 1;
13815 }
13816
13817
13818 static PyObject *_wrap_NullImage_get(void) {
13819 PyObject *pyobj;
13820
13821 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13822 return pyobj;
13823 }
13824
13825
13826 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13827 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13828 return 1;
13829 }
13830
13831
13832 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13833 PyObject *pyobj;
13834
13835 {
13836 #if wxUSE_UNICODE
13837 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13838 #else
13839 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13840 #endif
13841 }
13842 return pyobj;
13843 }
13844
13845
13846 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13847 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13848 return 1;
13849 }
13850
13851
13852 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13853 PyObject *pyobj;
13854
13855 {
13856 #if wxUSE_UNICODE
13857 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13858 #else
13859 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13860 #endif
13861 }
13862 return pyobj;
13863 }
13864
13865
13866 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13867 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13868 return 1;
13869 }
13870
13871
13872 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13873 PyObject *pyobj;
13874
13875 {
13876 #if wxUSE_UNICODE
13877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13878 #else
13879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13880 #endif
13881 }
13882 return pyobj;
13883 }
13884
13885
13886 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13887 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13888 return 1;
13889 }
13890
13891
13892 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13893 PyObject *pyobj;
13894
13895 {
13896 #if wxUSE_UNICODE
13897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13898 #else
13899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13900 #endif
13901 }
13902 return pyobj;
13903 }
13904
13905
13906 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13907 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13908 return 1;
13909 }
13910
13911
13912 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13913 PyObject *pyobj;
13914
13915 {
13916 #if wxUSE_UNICODE
13917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13918 #else
13919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13920 #endif
13921 }
13922 return pyobj;
13923 }
13924
13925
13926 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13927 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13928 return 1;
13929 }
13930
13931
13932 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13933 PyObject *pyobj;
13934
13935 {
13936 #if wxUSE_UNICODE
13937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13938 #else
13939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13940 #endif
13941 }
13942 return pyobj;
13943 }
13944
13945
13946 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13947 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13948 return 1;
13949 }
13950
13951
13952 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13953 PyObject *pyobj;
13954
13955 {
13956 #if wxUSE_UNICODE
13957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13958 #else
13959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13960 #endif
13961 }
13962 return pyobj;
13963 }
13964
13965
13966 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13967 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13968 return 1;
13969 }
13970
13971
13972 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13973 PyObject *pyobj;
13974
13975 {
13976 #if wxUSE_UNICODE
13977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13978 #else
13979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13980 #endif
13981 }
13982 return pyobj;
13983 }
13984
13985
13986 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13987 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13988 return 1;
13989 }
13990
13991
13992 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13993 PyObject *pyobj;
13994
13995 {
13996 #if wxUSE_UNICODE
13997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13998 #else
13999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14000 #endif
14001 }
14002 return pyobj;
14003 }
14004
14005
14006 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14007 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14008 return 1;
14009 }
14010
14011
14012 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14013 PyObject *pyobj;
14014
14015 {
14016 #if wxUSE_UNICODE
14017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14018 #else
14019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14020 #endif
14021 }
14022 return pyobj;
14023 }
14024
14025
14026 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14027 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14028 return 1;
14029 }
14030
14031
14032 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14033 PyObject *pyobj;
14034
14035 {
14036 #if wxUSE_UNICODE
14037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14038 #else
14039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14040 #endif
14041 }
14042 return pyobj;
14043 }
14044
14045
14046 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14047 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14048 return 1;
14049 }
14050
14051
14052 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14053 PyObject *pyobj;
14054
14055 {
14056 #if wxUSE_UNICODE
14057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14058 #else
14059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14060 #endif
14061 }
14062 return pyobj;
14063 }
14064
14065
14066 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14067 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14068 return 1;
14069 }
14070
14071
14072 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14073 PyObject *pyobj;
14074
14075 {
14076 #if wxUSE_UNICODE
14077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14078 #else
14079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14080 #endif
14081 }
14082 return pyobj;
14083 }
14084
14085
14086 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14087 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14088 return 1;
14089 }
14090
14091
14092 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14093 PyObject *pyobj;
14094
14095 {
14096 #if wxUSE_UNICODE
14097 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14098 #else
14099 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14100 #endif
14101 }
14102 return pyobj;
14103 }
14104
14105
14106 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14107 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14108 return 1;
14109 }
14110
14111
14112 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14113 PyObject *pyobj;
14114
14115 {
14116 #if wxUSE_UNICODE
14117 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14118 #else
14119 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14120 #endif
14121 }
14122 return pyobj;
14123 }
14124
14125
14126 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14127 PyObject *resultobj;
14128 wxBMPHandler *result;
14129 char *kwnames[] = {
14130 NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 result = (wxBMPHandler *)new wxBMPHandler();
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14149 PyObject *obj;
14150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14151 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14152 Py_INCREF(obj);
14153 return Py_BuildValue((char *)"");
14154 }
14155 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj;
14157 wxICOHandler *result;
14158 char *kwnames[] = {
14159 NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 result = (wxICOHandler *)new wxICOHandler();
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14178 PyObject *obj;
14179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14180 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14181 Py_INCREF(obj);
14182 return Py_BuildValue((char *)"");
14183 }
14184 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxCURHandler *result;
14187 char *kwnames[] = {
14188 NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (wxCURHandler *)new wxCURHandler();
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14207 PyObject *obj;
14208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14209 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14210 Py_INCREF(obj);
14211 return Py_BuildValue((char *)"");
14212 }
14213 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj;
14215 wxANIHandler *result;
14216 char *kwnames[] = {
14217 NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 result = (wxANIHandler *)new wxANIHandler();
14224
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14236 PyObject *obj;
14237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14238 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14239 Py_INCREF(obj);
14240 return Py_BuildValue((char *)"");
14241 }
14242 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxPNGHandler *result;
14245 char *kwnames[] = {
14246 NULL
14247 };
14248
14249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (wxPNGHandler *)new wxPNGHandler();
14253
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14258 return resultobj;
14259 fail:
14260 return NULL;
14261 }
14262
14263
14264 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14265 PyObject *obj;
14266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14267 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14268 Py_INCREF(obj);
14269 return Py_BuildValue((char *)"");
14270 }
14271 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj;
14273 wxGIFHandler *result;
14274 char *kwnames[] = {
14275 NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 result = (wxGIFHandler *)new wxGIFHandler();
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14287 return resultobj;
14288 fail:
14289 return NULL;
14290 }
14291
14292
14293 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14294 PyObject *obj;
14295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14296 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14297 Py_INCREF(obj);
14298 return Py_BuildValue((char *)"");
14299 }
14300 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxPCXHandler *result;
14303 char *kwnames[] = {
14304 NULL
14305 };
14306
14307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 result = (wxPCXHandler *)new wxPCXHandler();
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14323 PyObject *obj;
14324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14325 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14326 Py_INCREF(obj);
14327 return Py_BuildValue((char *)"");
14328 }
14329 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj;
14331 wxJPEGHandler *result;
14332 char *kwnames[] = {
14333 NULL
14334 };
14335
14336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (wxJPEGHandler *)new wxJPEGHandler();
14340
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14352 PyObject *obj;
14353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14354 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14355 Py_INCREF(obj);
14356 return Py_BuildValue((char *)"");
14357 }
14358 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxPNMHandler *result;
14361 char *kwnames[] = {
14362 NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (wxPNMHandler *)new wxPNMHandler();
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14381 PyObject *obj;
14382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14383 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14384 Py_INCREF(obj);
14385 return Py_BuildValue((char *)"");
14386 }
14387 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj;
14389 wxXPMHandler *result;
14390 char *kwnames[] = {
14391 NULL
14392 };
14393
14394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (wxXPMHandler *)new wxXPMHandler();
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14410 PyObject *obj;
14411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14412 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14413 Py_INCREF(obj);
14414 return Py_BuildValue((char *)"");
14415 }
14416 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxTIFFHandler *result;
14419 char *kwnames[] = {
14420 NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxTIFFHandler *)new wxTIFFHandler();
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14439 PyObject *obj;
14440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14441 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14442 Py_INCREF(obj);
14443 return Py_BuildValue((char *)"");
14444 }
14445 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxImage *arg1 = 0 ;
14448 wxImage *arg2 = 0 ;
14449 int arg3 = (int) 236 ;
14450 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14451 bool result;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 PyObject * obj2 = 0 ;
14455 PyObject * obj3 = 0 ;
14456 char *kwnames[] = {
14457 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14458 };
14459
14460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14461 {
14462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14463 if (SWIG_arg_fail(1)) SWIG_fail;
14464 if (arg1 == NULL) {
14465 SWIG_null_ref("wxImage");
14466 }
14467 if (SWIG_arg_fail(1)) SWIG_fail;
14468 }
14469 {
14470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14471 if (SWIG_arg_fail(2)) SWIG_fail;
14472 if (arg2 == NULL) {
14473 SWIG_null_ref("wxImage");
14474 }
14475 if (SWIG_arg_fail(2)) SWIG_fail;
14476 }
14477 if (obj2) {
14478 {
14479 arg3 = (int)(SWIG_As_int(obj2));
14480 if (SWIG_arg_fail(3)) SWIG_fail;
14481 }
14482 }
14483 if (obj3) {
14484 {
14485 arg4 = (int)(SWIG_As_int(obj3));
14486 if (SWIG_arg_fail(4)) SWIG_fail;
14487 }
14488 }
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14492
14493 wxPyEndAllowThreads(__tstate);
14494 if (PyErr_Occurred()) SWIG_fail;
14495 }
14496 {
14497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14498 }
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14506 PyObject *obj;
14507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14508 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14509 Py_INCREF(obj);
14510 return Py_BuildValue((char *)"");
14511 }
14512 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14513 PyObject *resultobj;
14514 wxEvtHandler *result;
14515 char *kwnames[] = {
14516 NULL
14517 };
14518
14519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 result = (wxEvtHandler *)new wxEvtHandler();
14523
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14535 PyObject *resultobj;
14536 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14537 wxEvtHandler *result;
14538 PyObject * obj0 = 0 ;
14539 char *kwnames[] = {
14540 (char *) "self", NULL
14541 };
14542
14543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14545 if (SWIG_arg_fail(1)) SWIG_fail;
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14549
14550 wxPyEndAllowThreads(__tstate);
14551 if (PyErr_Occurred()) SWIG_fail;
14552 }
14553 {
14554 resultobj = wxPyMake_wxObject(result, 0);
14555 }
14556 return resultobj;
14557 fail:
14558 return NULL;
14559 }
14560
14561
14562 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj;
14564 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14565 wxEvtHandler *result;
14566 PyObject * obj0 = 0 ;
14567 char *kwnames[] = {
14568 (char *) "self", NULL
14569 };
14570
14571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14573 if (SWIG_arg_fail(1)) SWIG_fail;
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14577
14578 wxPyEndAllowThreads(__tstate);
14579 if (PyErr_Occurred()) SWIG_fail;
14580 }
14581 {
14582 resultobj = wxPyMake_wxObject(result, 0);
14583 }
14584 return resultobj;
14585 fail:
14586 return NULL;
14587 }
14588
14589
14590 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14591 PyObject *resultobj;
14592 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14593 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14594 PyObject * obj0 = 0 ;
14595 PyObject * obj1 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self",(char *) "handler", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14604 if (SWIG_arg_fail(2)) SWIG_fail;
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 (arg1)->SetNextHandler(arg2);
14608
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 Py_INCREF(Py_None); resultobj = Py_None;
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14622 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "handler", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(2)) SWIG_fail;
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 (arg1)->SetPreviousHandler(arg2);
14637
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 Py_INCREF(Py_None); resultobj = Py_None;
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj;
14650 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14651 bool result;
14652 PyObject * obj0 = 0 ;
14653 char *kwnames[] = {
14654 (char *) "self", NULL
14655 };
14656
14657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14659 if (SWIG_arg_fail(1)) SWIG_fail;
14660 {
14661 PyThreadState* __tstate = wxPyBeginAllowThreads();
14662 result = (bool)(arg1)->GetEvtHandlerEnabled();
14663
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 {
14668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14669 }
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14677 PyObject *resultobj;
14678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14679 bool arg2 ;
14680 PyObject * obj0 = 0 ;
14681 PyObject * obj1 = 0 ;
14682 char *kwnames[] = {
14683 (char *) "self",(char *) "enabled", NULL
14684 };
14685
14686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14688 if (SWIG_arg_fail(1)) SWIG_fail;
14689 {
14690 arg2 = (bool)(SWIG_As_bool(obj1));
14691 if (SWIG_arg_fail(2)) SWIG_fail;
14692 }
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 (arg1)->SetEvtHandlerEnabled(arg2);
14696
14697 wxPyEndAllowThreads(__tstate);
14698 if (PyErr_Occurred()) SWIG_fail;
14699 }
14700 Py_INCREF(Py_None); resultobj = Py_None;
14701 return resultobj;
14702 fail:
14703 return NULL;
14704 }
14705
14706
14707 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14708 PyObject *resultobj;
14709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14710 wxEvent *arg2 = 0 ;
14711 bool result;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 char *kwnames[] = {
14715 (char *) "self",(char *) "event", NULL
14716 };
14717
14718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14720 if (SWIG_arg_fail(1)) SWIG_fail;
14721 {
14722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14723 if (SWIG_arg_fail(2)) SWIG_fail;
14724 if (arg2 == NULL) {
14725 SWIG_null_ref("wxEvent");
14726 }
14727 if (SWIG_arg_fail(2)) SWIG_fail;
14728 }
14729 {
14730 PyThreadState* __tstate = wxPyBeginAllowThreads();
14731 result = (bool)(arg1)->ProcessEvent(*arg2);
14732
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 {
14737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14738 }
14739 return resultobj;
14740 fail:
14741 return NULL;
14742 }
14743
14744
14745 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14746 PyObject *resultobj;
14747 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14748 wxEvent *arg2 = 0 ;
14749 PyObject * obj0 = 0 ;
14750 PyObject * obj1 = 0 ;
14751 char *kwnames[] = {
14752 (char *) "self",(char *) "event", NULL
14753 };
14754
14755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14757 if (SWIG_arg_fail(1)) SWIG_fail;
14758 {
14759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14760 if (SWIG_arg_fail(2)) SWIG_fail;
14761 if (arg2 == NULL) {
14762 SWIG_null_ref("wxEvent");
14763 }
14764 if (SWIG_arg_fail(2)) SWIG_fail;
14765 }
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 (arg1)->AddPendingEvent(*arg2);
14769
14770 wxPyEndAllowThreads(__tstate);
14771 if (PyErr_Occurred()) SWIG_fail;
14772 }
14773 Py_INCREF(Py_None); resultobj = Py_None;
14774 return resultobj;
14775 fail:
14776 return NULL;
14777 }
14778
14779
14780 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14781 PyObject *resultobj;
14782 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14783 PyObject * obj0 = 0 ;
14784 char *kwnames[] = {
14785 (char *) "self", NULL
14786 };
14787
14788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14790 if (SWIG_arg_fail(1)) SWIG_fail;
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 (arg1)->ProcessPendingEvents();
14794
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 Py_INCREF(Py_None); resultobj = Py_None;
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14808 int arg2 ;
14809 int arg3 ;
14810 int arg4 ;
14811 PyObject *arg5 = (PyObject *) 0 ;
14812 PyObject * obj0 = 0 ;
14813 PyObject * obj1 = 0 ;
14814 PyObject * obj2 = 0 ;
14815 PyObject * obj3 = 0 ;
14816 PyObject * obj4 = 0 ;
14817 char *kwnames[] = {
14818 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14819 };
14820
14821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14823 if (SWIG_arg_fail(1)) SWIG_fail;
14824 {
14825 arg2 = (int)(SWIG_As_int(obj1));
14826 if (SWIG_arg_fail(2)) SWIG_fail;
14827 }
14828 {
14829 arg3 = (int)(SWIG_As_int(obj2));
14830 if (SWIG_arg_fail(3)) SWIG_fail;
14831 }
14832 {
14833 arg4 = (int)(SWIG_As_int(obj3));
14834 if (SWIG_arg_fail(4)) SWIG_fail;
14835 }
14836 arg5 = obj4;
14837 {
14838 PyThreadState* __tstate = wxPyBeginAllowThreads();
14839 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14840
14841 wxPyEndAllowThreads(__tstate);
14842 if (PyErr_Occurred()) SWIG_fail;
14843 }
14844 Py_INCREF(Py_None); resultobj = Py_None;
14845 return resultobj;
14846 fail:
14847 return NULL;
14848 }
14849
14850
14851 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14852 PyObject *resultobj;
14853 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14854 int arg2 ;
14855 int arg3 = (int) -1 ;
14856 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14857 bool result;
14858 PyObject * obj0 = 0 ;
14859 PyObject * obj1 = 0 ;
14860 PyObject * obj2 = 0 ;
14861 PyObject * obj3 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14868 if (SWIG_arg_fail(1)) SWIG_fail;
14869 {
14870 arg2 = (int)(SWIG_As_int(obj1));
14871 if (SWIG_arg_fail(2)) SWIG_fail;
14872 }
14873 if (obj2) {
14874 {
14875 arg3 = (int)(SWIG_As_int(obj2));
14876 if (SWIG_arg_fail(3)) SWIG_fail;
14877 }
14878 }
14879 if (obj3) {
14880 {
14881 arg4 = (wxEventType)(SWIG_As_int(obj3));
14882 if (SWIG_arg_fail(4)) SWIG_fail;
14883 }
14884 }
14885 {
14886 PyThreadState* __tstate = wxPyBeginAllowThreads();
14887 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14888
14889 wxPyEndAllowThreads(__tstate);
14890 if (PyErr_Occurred()) SWIG_fail;
14891 }
14892 {
14893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14894 }
14895 return resultobj;
14896 fail:
14897 return NULL;
14898 }
14899
14900
14901 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14902 PyObject *resultobj;
14903 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14904 PyObject *arg2 = (PyObject *) 0 ;
14905 bool arg3 = (bool) true ;
14906 PyObject * obj0 = 0 ;
14907 PyObject * obj1 = 0 ;
14908 PyObject * obj2 = 0 ;
14909 char *kwnames[] = {
14910 (char *) "self",(char *) "_self",(char *) "incref", NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14915 if (SWIG_arg_fail(1)) SWIG_fail;
14916 arg2 = obj1;
14917 if (obj2) {
14918 {
14919 arg3 = (bool)(SWIG_As_bool(obj2));
14920 if (SWIG_arg_fail(3)) SWIG_fail;
14921 }
14922 }
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14926
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 Py_INCREF(Py_None); resultobj = Py_None;
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14938 PyObject *obj;
14939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14940 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14941 Py_INCREF(obj);
14942 return Py_BuildValue((char *)"");
14943 }
14944 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14945 PyObject *resultobj;
14946 wxEventType result;
14947 char *kwnames[] = {
14948 NULL
14949 };
14950
14951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 result = (wxEventType)wxNewEventType();
14955
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 {
14960 resultobj = SWIG_From_int((int)(result));
14961 }
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14969 PyObject *resultobj;
14970 wxEvent *arg1 = (wxEvent *) 0 ;
14971 PyObject * obj0 = 0 ;
14972 char *kwnames[] = {
14973 (char *) "self", NULL
14974 };
14975
14976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14978 if (SWIG_arg_fail(1)) SWIG_fail;
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 delete arg1;
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 Py_INCREF(Py_None); resultobj = Py_None;
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj;
14995 wxEvent *arg1 = (wxEvent *) 0 ;
14996 wxEventType arg2 ;
14997 PyObject * obj0 = 0 ;
14998 PyObject * obj1 = 0 ;
14999 char *kwnames[] = {
15000 (char *) "self",(char *) "typ", NULL
15001 };
15002
15003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15005 if (SWIG_arg_fail(1)) SWIG_fail;
15006 {
15007 arg2 = (wxEventType)(SWIG_As_int(obj1));
15008 if (SWIG_arg_fail(2)) SWIG_fail;
15009 }
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 (arg1)->SetEventType(arg2);
15013
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 Py_INCREF(Py_None); resultobj = Py_None;
15018 return resultobj;
15019 fail:
15020 return NULL;
15021 }
15022
15023
15024 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj;
15026 wxEvent *arg1 = (wxEvent *) 0 ;
15027 wxEventType result;
15028 PyObject * obj0 = 0 ;
15029 char *kwnames[] = {
15030 (char *) "self", NULL
15031 };
15032
15033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15035 if (SWIG_arg_fail(1)) SWIG_fail;
15036 {
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15039
15040 wxPyEndAllowThreads(__tstate);
15041 if (PyErr_Occurred()) SWIG_fail;
15042 }
15043 {
15044 resultobj = SWIG_From_int((int)(result));
15045 }
15046 return resultobj;
15047 fail:
15048 return NULL;
15049 }
15050
15051
15052 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15053 PyObject *resultobj;
15054 wxEvent *arg1 = (wxEvent *) 0 ;
15055 wxObject *result;
15056 PyObject * obj0 = 0 ;
15057 char *kwnames[] = {
15058 (char *) "self", NULL
15059 };
15060
15061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15063 if (SWIG_arg_fail(1)) SWIG_fail;
15064 {
15065 PyThreadState* __tstate = wxPyBeginAllowThreads();
15066 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15067
15068 wxPyEndAllowThreads(__tstate);
15069 if (PyErr_Occurred()) SWIG_fail;
15070 }
15071 {
15072 resultobj = wxPyMake_wxObject(result, 0);
15073 }
15074 return resultobj;
15075 fail:
15076 return NULL;
15077 }
15078
15079
15080 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj;
15082 wxEvent *arg1 = (wxEvent *) 0 ;
15083 wxObject *arg2 = (wxObject *) 0 ;
15084 PyObject * obj0 = 0 ;
15085 PyObject * obj1 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self",(char *) "obj", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15094 if (SWIG_arg_fail(2)) SWIG_fail;
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 (arg1)->SetEventObject(arg2);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 Py_INCREF(Py_None); resultobj = Py_None;
15103 return resultobj;
15104 fail:
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxEvent *arg1 = (wxEvent *) 0 ;
15112 long result;
15113 PyObject * obj0 = 0 ;
15114 char *kwnames[] = {
15115 (char *) "self", NULL
15116 };
15117
15118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15120 if (SWIG_arg_fail(1)) SWIG_fail;
15121 {
15122 PyThreadState* __tstate = wxPyBeginAllowThreads();
15123 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15124
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 {
15129 resultobj = SWIG_From_long((long)(result));
15130 }
15131 return resultobj;
15132 fail:
15133 return NULL;
15134 }
15135
15136
15137 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15138 PyObject *resultobj;
15139 wxEvent *arg1 = (wxEvent *) 0 ;
15140 long arg2 = (long) 0 ;
15141 PyObject * obj0 = 0 ;
15142 PyObject * obj1 = 0 ;
15143 char *kwnames[] = {
15144 (char *) "self",(char *) "ts", NULL
15145 };
15146
15147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15149 if (SWIG_arg_fail(1)) SWIG_fail;
15150 if (obj1) {
15151 {
15152 arg2 = (long)(SWIG_As_long(obj1));
15153 if (SWIG_arg_fail(2)) SWIG_fail;
15154 }
15155 }
15156 {
15157 PyThreadState* __tstate = wxPyBeginAllowThreads();
15158 (arg1)->SetTimestamp(arg2);
15159
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 Py_INCREF(Py_None); resultobj = Py_None;
15164 return resultobj;
15165 fail:
15166 return NULL;
15167 }
15168
15169
15170 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15171 PyObject *resultobj;
15172 wxEvent *arg1 = (wxEvent *) 0 ;
15173 int result;
15174 PyObject * obj0 = 0 ;
15175 char *kwnames[] = {
15176 (char *) "self", NULL
15177 };
15178
15179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15181 if (SWIG_arg_fail(1)) SWIG_fail;
15182 {
15183 PyThreadState* __tstate = wxPyBeginAllowThreads();
15184 result = (int)((wxEvent const *)arg1)->GetId();
15185
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 {
15190 resultobj = SWIG_From_int((int)(result));
15191 }
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj;
15200 wxEvent *arg1 = (wxEvent *) 0 ;
15201 int arg2 ;
15202 PyObject * obj0 = 0 ;
15203 PyObject * obj1 = 0 ;
15204 char *kwnames[] = {
15205 (char *) "self",(char *) "Id", NULL
15206 };
15207
15208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15210 if (SWIG_arg_fail(1)) SWIG_fail;
15211 {
15212 arg2 = (int)(SWIG_As_int(obj1));
15213 if (SWIG_arg_fail(2)) SWIG_fail;
15214 }
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 (arg1)->SetId(arg2);
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 Py_INCREF(Py_None); resultobj = Py_None;
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj;
15231 wxEvent *arg1 = (wxEvent *) 0 ;
15232 bool result;
15233 PyObject * obj0 = 0 ;
15234 char *kwnames[] = {
15235 (char *) "self", NULL
15236 };
15237
15238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15240 if (SWIG_arg_fail(1)) SWIG_fail;
15241 {
15242 PyThreadState* __tstate = wxPyBeginAllowThreads();
15243 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15244
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 {
15249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15250 }
15251 return resultobj;
15252 fail:
15253 return NULL;
15254 }
15255
15256
15257 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15258 PyObject *resultobj;
15259 wxEvent *arg1 = (wxEvent *) 0 ;
15260 bool arg2 = (bool) true ;
15261 PyObject * obj0 = 0 ;
15262 PyObject * obj1 = 0 ;
15263 char *kwnames[] = {
15264 (char *) "self",(char *) "skip", NULL
15265 };
15266
15267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15269 if (SWIG_arg_fail(1)) SWIG_fail;
15270 if (obj1) {
15271 {
15272 arg2 = (bool)(SWIG_As_bool(obj1));
15273 if (SWIG_arg_fail(2)) SWIG_fail;
15274 }
15275 }
15276 {
15277 PyThreadState* __tstate = wxPyBeginAllowThreads();
15278 (arg1)->Skip(arg2);
15279
15280 wxPyEndAllowThreads(__tstate);
15281 if (PyErr_Occurred()) SWIG_fail;
15282 }
15283 Py_INCREF(Py_None); resultobj = Py_None;
15284 return resultobj;
15285 fail:
15286 return NULL;
15287 }
15288
15289
15290 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15291 PyObject *resultobj;
15292 wxEvent *arg1 = (wxEvent *) 0 ;
15293 bool result;
15294 PyObject * obj0 = 0 ;
15295 char *kwnames[] = {
15296 (char *) "self", NULL
15297 };
15298
15299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15301 if (SWIG_arg_fail(1)) SWIG_fail;
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15305
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 {
15310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15311 }
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15319 PyObject *resultobj;
15320 wxEvent *arg1 = (wxEvent *) 0 ;
15321 bool result;
15322 PyObject * obj0 = 0 ;
15323 char *kwnames[] = {
15324 (char *) "self", NULL
15325 };
15326
15327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15329 if (SWIG_arg_fail(1)) SWIG_fail;
15330 {
15331 PyThreadState* __tstate = wxPyBeginAllowThreads();
15332 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15333
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 {
15338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15339 }
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15347 PyObject *resultobj;
15348 wxEvent *arg1 = (wxEvent *) 0 ;
15349 int result;
15350 PyObject * obj0 = 0 ;
15351 char *kwnames[] = {
15352 (char *) "self", NULL
15353 };
15354
15355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15357 if (SWIG_arg_fail(1)) SWIG_fail;
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (int)(arg1)->StopPropagation();
15361
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 {
15366 resultobj = SWIG_From_int((int)(result));
15367 }
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15375 PyObject *resultobj;
15376 wxEvent *arg1 = (wxEvent *) 0 ;
15377 int arg2 ;
15378 PyObject * obj0 = 0 ;
15379 PyObject * obj1 = 0 ;
15380 char *kwnames[] = {
15381 (char *) "self",(char *) "propagationLevel", NULL
15382 };
15383
15384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(1)) SWIG_fail;
15387 {
15388 arg2 = (int)(SWIG_As_int(obj1));
15389 if (SWIG_arg_fail(2)) SWIG_fail;
15390 }
15391 {
15392 PyThreadState* __tstate = wxPyBeginAllowThreads();
15393 (arg1)->ResumePropagation(arg2);
15394
15395 wxPyEndAllowThreads(__tstate);
15396 if (PyErr_Occurred()) SWIG_fail;
15397 }
15398 Py_INCREF(Py_None); resultobj = Py_None;
15399 return resultobj;
15400 fail:
15401 return NULL;
15402 }
15403
15404
15405 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15406 PyObject *resultobj;
15407 wxEvent *arg1 = (wxEvent *) 0 ;
15408 wxEvent *result;
15409 PyObject * obj0 = 0 ;
15410 char *kwnames[] = {
15411 (char *) "self", NULL
15412 };
15413
15414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15416 if (SWIG_arg_fail(1)) SWIG_fail;
15417 {
15418 PyThreadState* __tstate = wxPyBeginAllowThreads();
15419 result = (wxEvent *)(arg1)->Clone();
15420
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15432 PyObject *obj;
15433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15434 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15435 Py_INCREF(obj);
15436 return Py_BuildValue((char *)"");
15437 }
15438 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj;
15440 wxEvent *arg1 = 0 ;
15441 wxPropagationDisabler *result;
15442 PyObject * obj0 = 0 ;
15443 char *kwnames[] = {
15444 (char *) "event", NULL
15445 };
15446
15447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15448 {
15449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15450 if (SWIG_arg_fail(1)) SWIG_fail;
15451 if (arg1 == NULL) {
15452 SWIG_null_ref("wxEvent");
15453 }
15454 if (SWIG_arg_fail(1)) SWIG_fail;
15455 }
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15459
15460 wxPyEndAllowThreads(__tstate);
15461 if (PyErr_Occurred()) SWIG_fail;
15462 }
15463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj;
15472 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15473 PyObject * obj0 = 0 ;
15474 char *kwnames[] = {
15475 (char *) "self", NULL
15476 };
15477
15478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15480 if (SWIG_arg_fail(1)) SWIG_fail;
15481 {
15482 PyThreadState* __tstate = wxPyBeginAllowThreads();
15483 delete arg1;
15484
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 Py_INCREF(Py_None); resultobj = Py_None;
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15496 PyObject *obj;
15497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15498 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15499 Py_INCREF(obj);
15500 return Py_BuildValue((char *)"");
15501 }
15502 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj;
15504 wxEvent *arg1 = 0 ;
15505 wxPropagateOnce *result;
15506 PyObject * obj0 = 0 ;
15507 char *kwnames[] = {
15508 (char *) "event", NULL
15509 };
15510
15511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15512 {
15513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15514 if (SWIG_arg_fail(1)) SWIG_fail;
15515 if (arg1 == NULL) {
15516 SWIG_null_ref("wxEvent");
15517 }
15518 if (SWIG_arg_fail(1)) SWIG_fail;
15519 }
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15523
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15528 return resultobj;
15529 fail:
15530 return NULL;
15531 }
15532
15533
15534 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj;
15536 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15537 PyObject * obj0 = 0 ;
15538 char *kwnames[] = {
15539 (char *) "self", NULL
15540 };
15541
15542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15544 if (SWIG_arg_fail(1)) SWIG_fail;
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 delete arg1;
15548
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 Py_INCREF(Py_None); resultobj = Py_None;
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15560 PyObject *obj;
15561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15562 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15563 Py_INCREF(obj);
15564 return Py_BuildValue((char *)"");
15565 }
15566 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj;
15568 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15569 int arg2 = (int) 0 ;
15570 wxCommandEvent *result;
15571 PyObject * obj0 = 0 ;
15572 PyObject * obj1 = 0 ;
15573 char *kwnames[] = {
15574 (char *) "commandType",(char *) "winid", NULL
15575 };
15576
15577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15578 if (obj0) {
15579 {
15580 arg1 = (wxEventType)(SWIG_As_int(obj0));
15581 if (SWIG_arg_fail(1)) SWIG_fail;
15582 }
15583 }
15584 if (obj1) {
15585 {
15586 arg2 = (int)(SWIG_As_int(obj1));
15587 if (SWIG_arg_fail(2)) SWIG_fail;
15588 }
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15593
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15598 return resultobj;
15599 fail:
15600 return NULL;
15601 }
15602
15603
15604 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15605 PyObject *resultobj;
15606 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15607 int result;
15608 PyObject * obj0 = 0 ;
15609 char *kwnames[] = {
15610 (char *) "self", NULL
15611 };
15612
15613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15615 if (SWIG_arg_fail(1)) SWIG_fail;
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15619
15620 wxPyEndAllowThreads(__tstate);
15621 if (PyErr_Occurred()) SWIG_fail;
15622 }
15623 {
15624 resultobj = SWIG_From_int((int)(result));
15625 }
15626 return resultobj;
15627 fail:
15628 return NULL;
15629 }
15630
15631
15632 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15633 PyObject *resultobj;
15634 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15635 wxString *arg2 = 0 ;
15636 bool temp2 = false ;
15637 PyObject * obj0 = 0 ;
15638 PyObject * obj1 = 0 ;
15639 char *kwnames[] = {
15640 (char *) "self",(char *) "s", NULL
15641 };
15642
15643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15645 if (SWIG_arg_fail(1)) SWIG_fail;
15646 {
15647 arg2 = wxString_in_helper(obj1);
15648 if (arg2 == NULL) SWIG_fail;
15649 temp2 = true;
15650 }
15651 {
15652 PyThreadState* __tstate = wxPyBeginAllowThreads();
15653 (arg1)->SetString((wxString const &)*arg2);
15654
15655 wxPyEndAllowThreads(__tstate);
15656 if (PyErr_Occurred()) SWIG_fail;
15657 }
15658 Py_INCREF(Py_None); resultobj = Py_None;
15659 {
15660 if (temp2)
15661 delete arg2;
15662 }
15663 return resultobj;
15664 fail:
15665 {
15666 if (temp2)
15667 delete arg2;
15668 }
15669 return NULL;
15670 }
15671
15672
15673 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15674 PyObject *resultobj;
15675 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15676 wxString result;
15677 PyObject * obj0 = 0 ;
15678 char *kwnames[] = {
15679 (char *) "self", NULL
15680 };
15681
15682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15684 if (SWIG_arg_fail(1)) SWIG_fail;
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = ((wxCommandEvent const *)arg1)->GetString();
15688
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 {
15693 #if wxUSE_UNICODE
15694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15695 #else
15696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15697 #endif
15698 }
15699 return resultobj;
15700 fail:
15701 return NULL;
15702 }
15703
15704
15705 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15706 PyObject *resultobj;
15707 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15708 bool result;
15709 PyObject * obj0 = 0 ;
15710 char *kwnames[] = {
15711 (char *) "self", NULL
15712 };
15713
15714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15716 if (SWIG_arg_fail(1)) SWIG_fail;
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15720
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 {
15725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15726 }
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj;
15735 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15736 bool result;
15737 PyObject * obj0 = 0 ;
15738 char *kwnames[] = {
15739 (char *) "self", NULL
15740 };
15741
15742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15744 if (SWIG_arg_fail(1)) SWIG_fail;
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15748
15749 wxPyEndAllowThreads(__tstate);
15750 if (PyErr_Occurred()) SWIG_fail;
15751 }
15752 {
15753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15754 }
15755 return resultobj;
15756 fail:
15757 return NULL;
15758 }
15759
15760
15761 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15762 PyObject *resultobj;
15763 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15764 long arg2 ;
15765 PyObject * obj0 = 0 ;
15766 PyObject * obj1 = 0 ;
15767 char *kwnames[] = {
15768 (char *) "self",(char *) "extraLong", NULL
15769 };
15770
15771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 {
15775 arg2 = (long)(SWIG_As_long(obj1));
15776 if (SWIG_arg_fail(2)) SWIG_fail;
15777 }
15778 {
15779 PyThreadState* __tstate = wxPyBeginAllowThreads();
15780 (arg1)->SetExtraLong(arg2);
15781
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 Py_INCREF(Py_None); resultobj = Py_None;
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj;
15794 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15795 long result;
15796 PyObject * obj0 = 0 ;
15797 char *kwnames[] = {
15798 (char *) "self", NULL
15799 };
15800
15801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15803 if (SWIG_arg_fail(1)) SWIG_fail;
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15807
15808 wxPyEndAllowThreads(__tstate);
15809 if (PyErr_Occurred()) SWIG_fail;
15810 }
15811 {
15812 resultobj = SWIG_From_long((long)(result));
15813 }
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15821 PyObject *resultobj;
15822 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15823 int arg2 ;
15824 PyObject * obj0 = 0 ;
15825 PyObject * obj1 = 0 ;
15826 char *kwnames[] = {
15827 (char *) "self",(char *) "i", NULL
15828 };
15829
15830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15832 if (SWIG_arg_fail(1)) SWIG_fail;
15833 {
15834 arg2 = (int)(SWIG_As_int(obj1));
15835 if (SWIG_arg_fail(2)) SWIG_fail;
15836 }
15837 {
15838 PyThreadState* __tstate = wxPyBeginAllowThreads();
15839 (arg1)->SetInt(arg2);
15840
15841 wxPyEndAllowThreads(__tstate);
15842 if (PyErr_Occurred()) SWIG_fail;
15843 }
15844 Py_INCREF(Py_None); resultobj = Py_None;
15845 return resultobj;
15846 fail:
15847 return NULL;
15848 }
15849
15850
15851 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15852 PyObject *resultobj;
15853 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15854 long result;
15855 PyObject * obj0 = 0 ;
15856 char *kwnames[] = {
15857 (char *) "self", NULL
15858 };
15859
15860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15862 if (SWIG_arg_fail(1)) SWIG_fail;
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 {
15871 resultobj = SWIG_From_long((long)(result));
15872 }
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj;
15881 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15882 wxEvent *result;
15883 PyObject * obj0 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15894
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15906 PyObject *obj;
15907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15908 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15909 Py_INCREF(obj);
15910 return Py_BuildValue((char *)"");
15911 }
15912 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj;
15914 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15915 int arg2 = (int) 0 ;
15916 wxNotifyEvent *result;
15917 PyObject * obj0 = 0 ;
15918 PyObject * obj1 = 0 ;
15919 char *kwnames[] = {
15920 (char *) "commandType",(char *) "winid", NULL
15921 };
15922
15923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15924 if (obj0) {
15925 {
15926 arg1 = (wxEventType)(SWIG_As_int(obj0));
15927 if (SWIG_arg_fail(1)) SWIG_fail;
15928 }
15929 }
15930 if (obj1) {
15931 {
15932 arg2 = (int)(SWIG_As_int(obj1));
15933 if (SWIG_arg_fail(2)) SWIG_fail;
15934 }
15935 }
15936 {
15937 PyThreadState* __tstate = wxPyBeginAllowThreads();
15938 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15939
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj;
15952 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15953 PyObject * obj0 = 0 ;
15954 char *kwnames[] = {
15955 (char *) "self", NULL
15956 };
15957
15958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15960 if (SWIG_arg_fail(1)) SWIG_fail;
15961 {
15962 PyThreadState* __tstate = wxPyBeginAllowThreads();
15963 (arg1)->Veto();
15964
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 Py_INCREF(Py_None); resultobj = Py_None;
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj;
15977 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15978 PyObject * obj0 = 0 ;
15979 char *kwnames[] = {
15980 (char *) "self", NULL
15981 };
15982
15983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15985 if (SWIG_arg_fail(1)) SWIG_fail;
15986 {
15987 PyThreadState* __tstate = wxPyBeginAllowThreads();
15988 (arg1)->Allow();
15989
15990 wxPyEndAllowThreads(__tstate);
15991 if (PyErr_Occurred()) SWIG_fail;
15992 }
15993 Py_INCREF(Py_None); resultobj = Py_None;
15994 return resultobj;
15995 fail:
15996 return NULL;
15997 }
15998
15999
16000 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16001 PyObject *resultobj;
16002 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16003 bool result;
16004 PyObject * obj0 = 0 ;
16005 char *kwnames[] = {
16006 (char *) "self", NULL
16007 };
16008
16009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16011 if (SWIG_arg_fail(1)) SWIG_fail;
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 result = (bool)(arg1)->IsAllowed();
16015
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 {
16020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16021 }
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16029 PyObject *obj;
16030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16031 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16032 Py_INCREF(obj);
16033 return Py_BuildValue((char *)"");
16034 }
16035 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj;
16037 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16038 int arg2 = (int) 0 ;
16039 int arg3 = (int) 0 ;
16040 int arg4 = (int) 0 ;
16041 wxScrollEvent *result;
16042 PyObject * obj0 = 0 ;
16043 PyObject * obj1 = 0 ;
16044 PyObject * obj2 = 0 ;
16045 PyObject * obj3 = 0 ;
16046 char *kwnames[] = {
16047 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16048 };
16049
16050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16051 if (obj0) {
16052 {
16053 arg1 = (wxEventType)(SWIG_As_int(obj0));
16054 if (SWIG_arg_fail(1)) SWIG_fail;
16055 }
16056 }
16057 if (obj1) {
16058 {
16059 arg2 = (int)(SWIG_As_int(obj1));
16060 if (SWIG_arg_fail(2)) SWIG_fail;
16061 }
16062 }
16063 if (obj2) {
16064 {
16065 arg3 = (int)(SWIG_As_int(obj2));
16066 if (SWIG_arg_fail(3)) SWIG_fail;
16067 }
16068 }
16069 if (obj3) {
16070 {
16071 arg4 = (int)(SWIG_As_int(obj3));
16072 if (SWIG_arg_fail(4)) SWIG_fail;
16073 }
16074 }
16075 {
16076 PyThreadState* __tstate = wxPyBeginAllowThreads();
16077 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16078
16079 wxPyEndAllowThreads(__tstate);
16080 if (PyErr_Occurred()) SWIG_fail;
16081 }
16082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16090 PyObject *resultobj;
16091 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16092 int result;
16093 PyObject * obj0 = 0 ;
16094 char *kwnames[] = {
16095 (char *) "self", NULL
16096 };
16097
16098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16100 if (SWIG_arg_fail(1)) SWIG_fail;
16101 {
16102 PyThreadState* __tstate = wxPyBeginAllowThreads();
16103 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16104
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 {
16109 resultobj = SWIG_From_int((int)(result));
16110 }
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16118 PyObject *resultobj;
16119 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16120 int result;
16121 PyObject * obj0 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16132
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 {
16137 resultobj = SWIG_From_int((int)(result));
16138 }
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16148 int arg2 ;
16149 PyObject * obj0 = 0 ;
16150 PyObject * obj1 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self",(char *) "orient", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 arg2 = (int)(SWIG_As_int(obj1));
16160 if (SWIG_arg_fail(2)) SWIG_fail;
16161 }
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 (arg1)->SetOrientation(arg2);
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 Py_INCREF(Py_None); resultobj = Py_None;
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16177 PyObject *resultobj;
16178 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16179 int arg2 ;
16180 PyObject * obj0 = 0 ;
16181 PyObject * obj1 = 0 ;
16182 char *kwnames[] = {
16183 (char *) "self",(char *) "pos", NULL
16184 };
16185
16186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16188 if (SWIG_arg_fail(1)) SWIG_fail;
16189 {
16190 arg2 = (int)(SWIG_As_int(obj1));
16191 if (SWIG_arg_fail(2)) SWIG_fail;
16192 }
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 (arg1)->SetPosition(arg2);
16196
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 Py_INCREF(Py_None); resultobj = Py_None;
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16208 PyObject *obj;
16209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16210 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16211 Py_INCREF(obj);
16212 return Py_BuildValue((char *)"");
16213 }
16214 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16215 PyObject *resultobj;
16216 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16217 int arg2 = (int) 0 ;
16218 int arg3 = (int) 0 ;
16219 wxScrollWinEvent *result;
16220 PyObject * obj0 = 0 ;
16221 PyObject * obj1 = 0 ;
16222 PyObject * obj2 = 0 ;
16223 char *kwnames[] = {
16224 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16225 };
16226
16227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16228 if (obj0) {
16229 {
16230 arg1 = (wxEventType)(SWIG_As_int(obj0));
16231 if (SWIG_arg_fail(1)) SWIG_fail;
16232 }
16233 }
16234 if (obj1) {
16235 {
16236 arg2 = (int)(SWIG_As_int(obj1));
16237 if (SWIG_arg_fail(2)) SWIG_fail;
16238 }
16239 }
16240 if (obj2) {
16241 {
16242 arg3 = (int)(SWIG_As_int(obj2));
16243 if (SWIG_arg_fail(3)) SWIG_fail;
16244 }
16245 }
16246 {
16247 PyThreadState* __tstate = wxPyBeginAllowThreads();
16248 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16249
16250 wxPyEndAllowThreads(__tstate);
16251 if (PyErr_Occurred()) SWIG_fail;
16252 }
16253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16254 return resultobj;
16255 fail:
16256 return NULL;
16257 }
16258
16259
16260 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16261 PyObject *resultobj;
16262 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16263 int result;
16264 PyObject * obj0 = 0 ;
16265 char *kwnames[] = {
16266 (char *) "self", NULL
16267 };
16268
16269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16271 if (SWIG_arg_fail(1)) SWIG_fail;
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16275
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 {
16280 resultobj = SWIG_From_int((int)(result));
16281 }
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16289 PyObject *resultobj;
16290 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16291 int result;
16292 PyObject * obj0 = 0 ;
16293 char *kwnames[] = {
16294 (char *) "self", NULL
16295 };
16296
16297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16299 if (SWIG_arg_fail(1)) SWIG_fail;
16300 {
16301 PyThreadState* __tstate = wxPyBeginAllowThreads();
16302 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16303
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 {
16308 resultobj = SWIG_From_int((int)(result));
16309 }
16310 return resultobj;
16311 fail:
16312 return NULL;
16313 }
16314
16315
16316 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj;
16318 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16319 int arg2 ;
16320 PyObject * obj0 = 0 ;
16321 PyObject * obj1 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self",(char *) "orient", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 {
16330 arg2 = (int)(SWIG_As_int(obj1));
16331 if (SWIG_arg_fail(2)) SWIG_fail;
16332 }
16333 {
16334 PyThreadState* __tstate = wxPyBeginAllowThreads();
16335 (arg1)->SetOrientation(arg2);
16336
16337 wxPyEndAllowThreads(__tstate);
16338 if (PyErr_Occurred()) SWIG_fail;
16339 }
16340 Py_INCREF(Py_None); resultobj = Py_None;
16341 return resultobj;
16342 fail:
16343 return NULL;
16344 }
16345
16346
16347 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16348 PyObject *resultobj;
16349 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16350 int arg2 ;
16351 PyObject * obj0 = 0 ;
16352 PyObject * obj1 = 0 ;
16353 char *kwnames[] = {
16354 (char *) "self",(char *) "pos", NULL
16355 };
16356
16357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16359 if (SWIG_arg_fail(1)) SWIG_fail;
16360 {
16361 arg2 = (int)(SWIG_As_int(obj1));
16362 if (SWIG_arg_fail(2)) SWIG_fail;
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 (arg1)->SetPosition(arg2);
16367
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 Py_INCREF(Py_None); resultobj = Py_None;
16372 return resultobj;
16373 fail:
16374 return NULL;
16375 }
16376
16377
16378 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16379 PyObject *obj;
16380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16381 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16382 Py_INCREF(obj);
16383 return Py_BuildValue((char *)"");
16384 }
16385 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16386 PyObject *resultobj;
16387 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16388 wxMouseEvent *result;
16389 PyObject * obj0 = 0 ;
16390 char *kwnames[] = {
16391 (char *) "mouseType", NULL
16392 };
16393
16394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16395 if (obj0) {
16396 {
16397 arg1 = (wxEventType)(SWIG_As_int(obj0));
16398 if (SWIG_arg_fail(1)) SWIG_fail;
16399 }
16400 }
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16404
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 {
16409 resultobj = wxPyMake_wxObject(result, 1);
16410 }
16411 return resultobj;
16412 fail:
16413 return NULL;
16414 }
16415
16416
16417 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16418 PyObject *resultobj;
16419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16420 bool result;
16421 PyObject * obj0 = 0 ;
16422 char *kwnames[] = {
16423 (char *) "self", NULL
16424 };
16425
16426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16428 if (SWIG_arg_fail(1)) SWIG_fail;
16429 {
16430 PyThreadState* __tstate = wxPyBeginAllowThreads();
16431 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16432
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 {
16437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16438 }
16439 return resultobj;
16440 fail:
16441 return NULL;
16442 }
16443
16444
16445 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16446 PyObject *resultobj;
16447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16448 int arg2 = (int) wxMOUSE_BTN_ANY ;
16449 bool result;
16450 PyObject * obj0 = 0 ;
16451 PyObject * obj1 = 0 ;
16452 char *kwnames[] = {
16453 (char *) "self",(char *) "but", NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16458 if (SWIG_arg_fail(1)) SWIG_fail;
16459 if (obj1) {
16460 {
16461 arg2 = (int)(SWIG_As_int(obj1));
16462 if (SWIG_arg_fail(2)) SWIG_fail;
16463 }
16464 }
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16468
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 {
16473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16474 }
16475 return resultobj;
16476 fail:
16477 return NULL;
16478 }
16479
16480
16481 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16482 PyObject *resultobj;
16483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16484 int arg2 = (int) wxMOUSE_BTN_ANY ;
16485 bool result;
16486 PyObject * obj0 = 0 ;
16487 PyObject * obj1 = 0 ;
16488 char *kwnames[] = {
16489 (char *) "self",(char *) "but", NULL
16490 };
16491
16492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16494 if (SWIG_arg_fail(1)) SWIG_fail;
16495 if (obj1) {
16496 {
16497 arg2 = (int)(SWIG_As_int(obj1));
16498 if (SWIG_arg_fail(2)) SWIG_fail;
16499 }
16500 }
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16504
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 {
16509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16510 }
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj;
16519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16520 int arg2 = (int) wxMOUSE_BTN_ANY ;
16521 bool result;
16522 PyObject * obj0 = 0 ;
16523 PyObject * obj1 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "self",(char *) "but", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 if (obj1) {
16532 {
16533 arg2 = (int)(SWIG_As_int(obj1));
16534 if (SWIG_arg_fail(2)) SWIG_fail;
16535 }
16536 }
16537 {
16538 PyThreadState* __tstate = wxPyBeginAllowThreads();
16539 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16540
16541 wxPyEndAllowThreads(__tstate);
16542 if (PyErr_Occurred()) SWIG_fail;
16543 }
16544 {
16545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16546 }
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj;
16555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16556 int arg2 ;
16557 bool result;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self",(char *) "but", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 arg2 = (int)(SWIG_As_int(obj1));
16569 if (SWIG_arg_fail(2)) SWIG_fail;
16570 }
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16590 int arg2 ;
16591 bool result;
16592 PyObject * obj0 = 0 ;
16593 PyObject * obj1 = 0 ;
16594 char *kwnames[] = {
16595 (char *) "self",(char *) "but", NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16600 if (SWIG_arg_fail(1)) SWIG_fail;
16601 {
16602 arg2 = (int)(SWIG_As_int(obj1));
16603 if (SWIG_arg_fail(2)) SWIG_fail;
16604 }
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16608
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 {
16613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16614 }
16615 return resultobj;
16616 fail:
16617 return NULL;
16618 }
16619
16620
16621 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16622 PyObject *resultobj;
16623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16624 int result;
16625 PyObject * obj0 = 0 ;
16626 char *kwnames[] = {
16627 (char *) "self", NULL
16628 };
16629
16630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16632 if (SWIG_arg_fail(1)) SWIG_fail;
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16636
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 {
16641 resultobj = SWIG_From_int((int)(result));
16642 }
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj;
16651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16652 bool result;
16653 PyObject * obj0 = 0 ;
16654 char *kwnames[] = {
16655 (char *) "self", NULL
16656 };
16657
16658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16660 if (SWIG_arg_fail(1)) SWIG_fail;
16661 {
16662 PyThreadState* __tstate = wxPyBeginAllowThreads();
16663 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16664
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 {
16669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16670 }
16671 return resultobj;
16672 fail:
16673 return NULL;
16674 }
16675
16676
16677 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16678 PyObject *resultobj;
16679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16680 bool result;
16681 PyObject * obj0 = 0 ;
16682 char *kwnames[] = {
16683 (char *) "self", NULL
16684 };
16685
16686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16688 if (SWIG_arg_fail(1)) SWIG_fail;
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16692
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 {
16697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16698 }
16699 return resultobj;
16700 fail:
16701 return NULL;
16702 }
16703
16704
16705 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16706 PyObject *resultobj;
16707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16708 bool result;
16709 PyObject * obj0 = 0 ;
16710 char *kwnames[] = {
16711 (char *) "self", NULL
16712 };
16713
16714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16716 if (SWIG_arg_fail(1)) SWIG_fail;
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16720
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 {
16725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16726 }
16727 return resultobj;
16728 fail:
16729 return NULL;
16730 }
16731
16732
16733 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16734 PyObject *resultobj;
16735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16736 bool result;
16737 PyObject * obj0 = 0 ;
16738 char *kwnames[] = {
16739 (char *) "self", NULL
16740 };
16741
16742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16744 if (SWIG_arg_fail(1)) SWIG_fail;
16745 {
16746 PyThreadState* __tstate = wxPyBeginAllowThreads();
16747 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16748
16749 wxPyEndAllowThreads(__tstate);
16750 if (PyErr_Occurred()) SWIG_fail;
16751 }
16752 {
16753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16754 }
16755 return resultobj;
16756 fail:
16757 return NULL;
16758 }
16759
16760
16761 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16762 PyObject *resultobj;
16763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16764 bool result;
16765 PyObject * obj0 = 0 ;
16766 char *kwnames[] = {
16767 (char *) "self", NULL
16768 };
16769
16770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16772 if (SWIG_arg_fail(1)) SWIG_fail;
16773 {
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16776
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 {
16781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16782 }
16783 return resultobj;
16784 fail:
16785 return NULL;
16786 }
16787
16788
16789 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16790 PyObject *resultobj;
16791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16792 bool result;
16793 PyObject * obj0 = 0 ;
16794 char *kwnames[] = {
16795 (char *) "self", NULL
16796 };
16797
16798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16800 if (SWIG_arg_fail(1)) SWIG_fail;
16801 {
16802 PyThreadState* __tstate = wxPyBeginAllowThreads();
16803 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16804
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 {
16809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16810 }
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj;
16819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16820 bool result;
16821 PyObject * obj0 = 0 ;
16822 char *kwnames[] = {
16823 (char *) "self", NULL
16824 };
16825
16826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16828 if (SWIG_arg_fail(1)) SWIG_fail;
16829 {
16830 PyThreadState* __tstate = wxPyBeginAllowThreads();
16831 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16832
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 {
16837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16838 }
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj;
16847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16848 bool result;
16849 PyObject * obj0 = 0 ;
16850 char *kwnames[] = {
16851 (char *) "self", NULL
16852 };
16853
16854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16856 if (SWIG_arg_fail(1)) SWIG_fail;
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 {
16865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16866 }
16867 return resultobj;
16868 fail:
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16876 bool result;
16877 PyObject * obj0 = 0 ;
16878 char *kwnames[] = {
16879 (char *) "self", NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16884 if (SWIG_arg_fail(1)) SWIG_fail;
16885 {
16886 PyThreadState* __tstate = wxPyBeginAllowThreads();
16887 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16888
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 {
16893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16894 }
16895 return resultobj;
16896 fail:
16897 return NULL;
16898 }
16899
16900
16901 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16902 PyObject *resultobj;
16903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16904 bool result;
16905 PyObject * obj0 = 0 ;
16906 char *kwnames[] = {
16907 (char *) "self", NULL
16908 };
16909
16910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16912 if (SWIG_arg_fail(1)) SWIG_fail;
16913 {
16914 PyThreadState* __tstate = wxPyBeginAllowThreads();
16915 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16916
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 {
16921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16922 }
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16930 PyObject *resultobj;
16931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16932 bool result;
16933 PyObject * obj0 = 0 ;
16934 char *kwnames[] = {
16935 (char *) "self", NULL
16936 };
16937
16938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16940 if (SWIG_arg_fail(1)) SWIG_fail;
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16944
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 {
16949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16950 }
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj;
16959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16960 bool result;
16961 PyObject * obj0 = 0 ;
16962 char *kwnames[] = {
16963 (char *) "self", NULL
16964 };
16965
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16968 if (SWIG_arg_fail(1)) SWIG_fail;
16969 {
16970 PyThreadState* __tstate = wxPyBeginAllowThreads();
16971 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16972
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 {
16977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16986 PyObject *resultobj;
16987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16988 bool result;
16989 PyObject * obj0 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "self", NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 {
16998 PyThreadState* __tstate = wxPyBeginAllowThreads();
16999 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17000
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 {
17005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17006 }
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17016 bool result;
17017 PyObject * obj0 = 0 ;
17018 char *kwnames[] = {
17019 (char *) "self", NULL
17020 };
17021
17022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17024 if (SWIG_arg_fail(1)) SWIG_fail;
17025 {
17026 PyThreadState* __tstate = wxPyBeginAllowThreads();
17027 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17028
17029 wxPyEndAllowThreads(__tstate);
17030 if (PyErr_Occurred()) SWIG_fail;
17031 }
17032 {
17033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17034 }
17035 return resultobj;
17036 fail:
17037 return NULL;
17038 }
17039
17040
17041 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17042 PyObject *resultobj;
17043 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17044 bool result;
17045 PyObject * obj0 = 0 ;
17046 char *kwnames[] = {
17047 (char *) "self", NULL
17048 };
17049
17050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17052 if (SWIG_arg_fail(1)) SWIG_fail;
17053 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 result = (bool)(arg1)->LeftIsDown();
17056
17057 wxPyEndAllowThreads(__tstate);
17058 if (PyErr_Occurred()) SWIG_fail;
17059 }
17060 {
17061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17062 }
17063 return resultobj;
17064 fail:
17065 return NULL;
17066 }
17067
17068
17069 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17070 PyObject *resultobj;
17071 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17072 bool result;
17073 PyObject * obj0 = 0 ;
17074 char *kwnames[] = {
17075 (char *) "self", NULL
17076 };
17077
17078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17080 if (SWIG_arg_fail(1)) SWIG_fail;
17081 {
17082 PyThreadState* __tstate = wxPyBeginAllowThreads();
17083 result = (bool)(arg1)->MiddleIsDown();
17084
17085 wxPyEndAllowThreads(__tstate);
17086 if (PyErr_Occurred()) SWIG_fail;
17087 }
17088 {
17089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17090 }
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj;
17099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17100 bool result;
17101 PyObject * obj0 = 0 ;
17102 char *kwnames[] = {
17103 (char *) "self", NULL
17104 };
17105
17106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17108 if (SWIG_arg_fail(1)) SWIG_fail;
17109 {
17110 PyThreadState* __tstate = wxPyBeginAllowThreads();
17111 result = (bool)(arg1)->RightIsDown();
17112
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 {
17117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17118 }
17119 return resultobj;
17120 fail:
17121 return NULL;
17122 }
17123
17124
17125 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17126 PyObject *resultobj;
17127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17128 bool result;
17129 PyObject * obj0 = 0 ;
17130 char *kwnames[] = {
17131 (char *) "self", NULL
17132 };
17133
17134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17136 if (SWIG_arg_fail(1)) SWIG_fail;
17137 {
17138 PyThreadState* __tstate = wxPyBeginAllowThreads();
17139 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17140
17141 wxPyEndAllowThreads(__tstate);
17142 if (PyErr_Occurred()) SWIG_fail;
17143 }
17144 {
17145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17146 }
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj;
17155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17156 bool result;
17157 PyObject * obj0 = 0 ;
17158 char *kwnames[] = {
17159 (char *) "self", NULL
17160 };
17161
17162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17164 if (SWIG_arg_fail(1)) SWIG_fail;
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 {
17173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17174 }
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj;
17183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17184 bool result;
17185 PyObject * obj0 = 0 ;
17186 char *kwnames[] = {
17187 (char *) "self", NULL
17188 };
17189
17190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17192 if (SWIG_arg_fail(1)) SWIG_fail;
17193 {
17194 PyThreadState* __tstate = wxPyBeginAllowThreads();
17195 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17196
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 {
17201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17202 }
17203 return resultobj;
17204 fail:
17205 return NULL;
17206 }
17207
17208
17209 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17210 PyObject *resultobj;
17211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17212 bool result;
17213 PyObject * obj0 = 0 ;
17214 char *kwnames[] = {
17215 (char *) "self", NULL
17216 };
17217
17218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17220 if (SWIG_arg_fail(1)) SWIG_fail;
17221 {
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17224
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 {
17229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17230 }
17231 return resultobj;
17232 fail:
17233 return NULL;
17234 }
17235
17236
17237 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj;
17239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17240 wxPoint result;
17241 PyObject * obj0 = 0 ;
17242 char *kwnames[] = {
17243 (char *) "self", NULL
17244 };
17245
17246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17248 if (SWIG_arg_fail(1)) SWIG_fail;
17249 {
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 result = (arg1)->GetPosition();
17252
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 {
17257 wxPoint * resultptr;
17258 resultptr = new wxPoint((wxPoint &)(result));
17259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17260 }
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj;
17269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17270 long *arg2 = (long *) 0 ;
17271 long *arg3 = (long *) 0 ;
17272 long temp2 ;
17273 int res2 = 0 ;
17274 long temp3 ;
17275 int res3 = 0 ;
17276 PyObject * obj0 = 0 ;
17277 char *kwnames[] = {
17278 (char *) "self", NULL
17279 };
17280
17281 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17282 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17285 if (SWIG_arg_fail(1)) SWIG_fail;
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 (arg1)->GetPosition(arg2,arg3);
17289
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 Py_INCREF(Py_None); resultobj = Py_None;
17294 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17295 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17296 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17297 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17298 return resultobj;
17299 fail:
17300 return NULL;
17301 }
17302
17303
17304 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17305 PyObject *resultobj;
17306 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17307 wxDC *arg2 = 0 ;
17308 wxPoint result;
17309 PyObject * obj0 = 0 ;
17310 PyObject * obj1 = 0 ;
17311 char *kwnames[] = {
17312 (char *) "self",(char *) "dc", NULL
17313 };
17314
17315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17317 if (SWIG_arg_fail(1)) SWIG_fail;
17318 {
17319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17320 if (SWIG_arg_fail(2)) SWIG_fail;
17321 if (arg2 == NULL) {
17322 SWIG_null_ref("wxDC");
17323 }
17324 if (SWIG_arg_fail(2)) SWIG_fail;
17325 }
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17329
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 {
17334 wxPoint * resultptr;
17335 resultptr = new wxPoint((wxPoint &)(result));
17336 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17337 }
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17345 PyObject *resultobj;
17346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17347 int result;
17348 PyObject * obj0 = 0 ;
17349 char *kwnames[] = {
17350 (char *) "self", NULL
17351 };
17352
17353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17355 if (SWIG_arg_fail(1)) SWIG_fail;
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = (int)((wxMouseEvent const *)arg1)->GetX();
17359
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 {
17364 resultobj = SWIG_From_int((int)(result));
17365 }
17366 return resultobj;
17367 fail:
17368 return NULL;
17369 }
17370
17371
17372 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj;
17374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17375 int result;
17376 PyObject * obj0 = 0 ;
17377 char *kwnames[] = {
17378 (char *) "self", NULL
17379 };
17380
17381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17383 if (SWIG_arg_fail(1)) SWIG_fail;
17384 {
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 result = (int)((wxMouseEvent const *)arg1)->GetY();
17387
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 {
17392 resultobj = SWIG_From_int((int)(result));
17393 }
17394 return resultobj;
17395 fail:
17396 return NULL;
17397 }
17398
17399
17400 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17401 PyObject *resultobj;
17402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17403 int result;
17404 PyObject * obj0 = 0 ;
17405 char *kwnames[] = {
17406 (char *) "self", NULL
17407 };
17408
17409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17411 if (SWIG_arg_fail(1)) SWIG_fail;
17412 {
17413 PyThreadState* __tstate = wxPyBeginAllowThreads();
17414 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17415
17416 wxPyEndAllowThreads(__tstate);
17417 if (PyErr_Occurred()) SWIG_fail;
17418 }
17419 {
17420 resultobj = SWIG_From_int((int)(result));
17421 }
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17429 PyObject *resultobj;
17430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17431 int result;
17432 PyObject * obj0 = 0 ;
17433 char *kwnames[] = {
17434 (char *) "self", NULL
17435 };
17436
17437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17439 if (SWIG_arg_fail(1)) SWIG_fail;
17440 {
17441 PyThreadState* __tstate = wxPyBeginAllowThreads();
17442 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17443
17444 wxPyEndAllowThreads(__tstate);
17445 if (PyErr_Occurred()) SWIG_fail;
17446 }
17447 {
17448 resultobj = SWIG_From_int((int)(result));
17449 }
17450 return resultobj;
17451 fail:
17452 return NULL;
17453 }
17454
17455
17456 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17457 PyObject *resultobj;
17458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17459 int result;
17460 PyObject * obj0 = 0 ;
17461 char *kwnames[] = {
17462 (char *) "self", NULL
17463 };
17464
17465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17467 if (SWIG_arg_fail(1)) SWIG_fail;
17468 {
17469 PyThreadState* __tstate = wxPyBeginAllowThreads();
17470 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17471
17472 wxPyEndAllowThreads(__tstate);
17473 if (PyErr_Occurred()) SWIG_fail;
17474 }
17475 {
17476 resultobj = SWIG_From_int((int)(result));
17477 }
17478 return resultobj;
17479 fail:
17480 return NULL;
17481 }
17482
17483
17484 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17485 PyObject *resultobj;
17486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17487 bool result;
17488 PyObject * obj0 = 0 ;
17489 char *kwnames[] = {
17490 (char *) "self", NULL
17491 };
17492
17493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17495 if (SWIG_arg_fail(1)) SWIG_fail;
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17499
17500 wxPyEndAllowThreads(__tstate);
17501 if (PyErr_Occurred()) SWIG_fail;
17502 }
17503 {
17504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17505 }
17506 return resultobj;
17507 fail:
17508 return NULL;
17509 }
17510
17511
17512 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17513 PyObject *resultobj;
17514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17515 int arg2 ;
17516 PyObject * obj0 = 0 ;
17517 PyObject * obj1 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self",(char *) "m_x", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 arg2 = (int)(SWIG_As_int(obj1));
17527 if (SWIG_arg_fail(2)) SWIG_fail;
17528 }
17529 if (arg1) (arg1)->m_x = arg2;
17530
17531 Py_INCREF(Py_None); resultobj = Py_None;
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17539 PyObject *resultobj;
17540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17541 int result;
17542 PyObject * obj0 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 result = (int) ((arg1)->m_x);
17551
17552 {
17553 resultobj = SWIG_From_int((int)(result));
17554 }
17555 return resultobj;
17556 fail:
17557 return NULL;
17558 }
17559
17560
17561 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17562 PyObject *resultobj;
17563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17564 int arg2 ;
17565 PyObject * obj0 = 0 ;
17566 PyObject * obj1 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self",(char *) "m_y", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 {
17575 arg2 = (int)(SWIG_As_int(obj1));
17576 if (SWIG_arg_fail(2)) SWIG_fail;
17577 }
17578 if (arg1) (arg1)->m_y = arg2;
17579
17580 Py_INCREF(Py_None); resultobj = Py_None;
17581 return resultobj;
17582 fail:
17583 return NULL;
17584 }
17585
17586
17587 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17588 PyObject *resultobj;
17589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17590 int result;
17591 PyObject * obj0 = 0 ;
17592 char *kwnames[] = {
17593 (char *) "self", NULL
17594 };
17595
17596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17598 if (SWIG_arg_fail(1)) SWIG_fail;
17599 result = (int) ((arg1)->m_y);
17600
17601 {
17602 resultobj = SWIG_From_int((int)(result));
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj;
17612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17613 bool arg2 ;
17614 PyObject * obj0 = 0 ;
17615 PyObject * obj1 = 0 ;
17616 char *kwnames[] = {
17617 (char *) "self",(char *) "m_leftDown", NULL
17618 };
17619
17620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17622 if (SWIG_arg_fail(1)) SWIG_fail;
17623 {
17624 arg2 = (bool)(SWIG_As_bool(obj1));
17625 if (SWIG_arg_fail(2)) SWIG_fail;
17626 }
17627 if (arg1) (arg1)->m_leftDown = arg2;
17628
17629 Py_INCREF(Py_None); resultobj = Py_None;
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17637 PyObject *resultobj;
17638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17639 bool result;
17640 PyObject * obj0 = 0 ;
17641 char *kwnames[] = {
17642 (char *) "self", NULL
17643 };
17644
17645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17647 if (SWIG_arg_fail(1)) SWIG_fail;
17648 result = (bool) ((arg1)->m_leftDown);
17649
17650 {
17651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17652 }
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj;
17661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17662 bool arg2 ;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 char *kwnames[] = {
17666 (char *) "self",(char *) "m_middleDown", NULL
17667 };
17668
17669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17671 if (SWIG_arg_fail(1)) SWIG_fail;
17672 {
17673 arg2 = (bool)(SWIG_As_bool(obj1));
17674 if (SWIG_arg_fail(2)) SWIG_fail;
17675 }
17676 if (arg1) (arg1)->m_middleDown = arg2;
17677
17678 Py_INCREF(Py_None); resultobj = Py_None;
17679 return resultobj;
17680 fail:
17681 return NULL;
17682 }
17683
17684
17685 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17688 bool result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 result = (bool) ((arg1)->m_middleDown);
17698
17699 {
17700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17701 }
17702 return resultobj;
17703 fail:
17704 return NULL;
17705 }
17706
17707
17708 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17709 PyObject *resultobj;
17710 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17711 bool arg2 ;
17712 PyObject * obj0 = 0 ;
17713 PyObject * obj1 = 0 ;
17714 char *kwnames[] = {
17715 (char *) "self",(char *) "m_rightDown", NULL
17716 };
17717
17718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17720 if (SWIG_arg_fail(1)) SWIG_fail;
17721 {
17722 arg2 = (bool)(SWIG_As_bool(obj1));
17723 if (SWIG_arg_fail(2)) SWIG_fail;
17724 }
17725 if (arg1) (arg1)->m_rightDown = arg2;
17726
17727 Py_INCREF(Py_None); resultobj = Py_None;
17728 return resultobj;
17729 fail:
17730 return NULL;
17731 }
17732
17733
17734 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17735 PyObject *resultobj;
17736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17737 bool result;
17738 PyObject * obj0 = 0 ;
17739 char *kwnames[] = {
17740 (char *) "self", NULL
17741 };
17742
17743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17745 if (SWIG_arg_fail(1)) SWIG_fail;
17746 result = (bool) ((arg1)->m_rightDown);
17747
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 return resultobj;
17752 fail:
17753 return NULL;
17754 }
17755
17756
17757 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj;
17759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17760 bool arg2 ;
17761 PyObject * obj0 = 0 ;
17762 PyObject * obj1 = 0 ;
17763 char *kwnames[] = {
17764 (char *) "self",(char *) "m_controlDown", NULL
17765 };
17766
17767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17769 if (SWIG_arg_fail(1)) SWIG_fail;
17770 {
17771 arg2 = (bool)(SWIG_As_bool(obj1));
17772 if (SWIG_arg_fail(2)) SWIG_fail;
17773 }
17774 if (arg1) (arg1)->m_controlDown = arg2;
17775
17776 Py_INCREF(Py_None); resultobj = Py_None;
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17784 PyObject *resultobj;
17785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17786 bool result;
17787 PyObject * obj0 = 0 ;
17788 char *kwnames[] = {
17789 (char *) "self", NULL
17790 };
17791
17792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17794 if (SWIG_arg_fail(1)) SWIG_fail;
17795 result = (bool) ((arg1)->m_controlDown);
17796
17797 {
17798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17799 }
17800 return resultobj;
17801 fail:
17802 return NULL;
17803 }
17804
17805
17806 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17807 PyObject *resultobj;
17808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17809 bool arg2 ;
17810 PyObject * obj0 = 0 ;
17811 PyObject * obj1 = 0 ;
17812 char *kwnames[] = {
17813 (char *) "self",(char *) "m_shiftDown", NULL
17814 };
17815
17816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17818 if (SWIG_arg_fail(1)) SWIG_fail;
17819 {
17820 arg2 = (bool)(SWIG_As_bool(obj1));
17821 if (SWIG_arg_fail(2)) SWIG_fail;
17822 }
17823 if (arg1) (arg1)->m_shiftDown = arg2;
17824
17825 Py_INCREF(Py_None); resultobj = Py_None;
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj;
17834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17835 bool result;
17836 PyObject * obj0 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(1)) SWIG_fail;
17844 result = (bool) ((arg1)->m_shiftDown);
17845
17846 {
17847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17848 }
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17858 bool arg2 ;
17859 PyObject * obj0 = 0 ;
17860 PyObject * obj1 = 0 ;
17861 char *kwnames[] = {
17862 (char *) "self",(char *) "m_altDown", NULL
17863 };
17864
17865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17867 if (SWIG_arg_fail(1)) SWIG_fail;
17868 {
17869 arg2 = (bool)(SWIG_As_bool(obj1));
17870 if (SWIG_arg_fail(2)) SWIG_fail;
17871 }
17872 if (arg1) (arg1)->m_altDown = arg2;
17873
17874 Py_INCREF(Py_None); resultobj = Py_None;
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17884 bool result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "self", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17892 if (SWIG_arg_fail(1)) SWIG_fail;
17893 result = (bool) ((arg1)->m_altDown);
17894
17895 {
17896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17897 }
17898 return resultobj;
17899 fail:
17900 return NULL;
17901 }
17902
17903
17904 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17905 PyObject *resultobj;
17906 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17907 bool arg2 ;
17908 PyObject * obj0 = 0 ;
17909 PyObject * obj1 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "self",(char *) "m_metaDown", NULL
17912 };
17913
17914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17916 if (SWIG_arg_fail(1)) SWIG_fail;
17917 {
17918 arg2 = (bool)(SWIG_As_bool(obj1));
17919 if (SWIG_arg_fail(2)) SWIG_fail;
17920 }
17921 if (arg1) (arg1)->m_metaDown = arg2;
17922
17923 Py_INCREF(Py_None); resultobj = Py_None;
17924 return resultobj;
17925 fail:
17926 return NULL;
17927 }
17928
17929
17930 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17931 PyObject *resultobj;
17932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17933 bool result;
17934 PyObject * obj0 = 0 ;
17935 char *kwnames[] = {
17936 (char *) "self", NULL
17937 };
17938
17939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17941 if (SWIG_arg_fail(1)) SWIG_fail;
17942 result = (bool) ((arg1)->m_metaDown);
17943
17944 {
17945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17946 }
17947 return resultobj;
17948 fail:
17949 return NULL;
17950 }
17951
17952
17953 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17954 PyObject *resultobj;
17955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17956 int arg2 ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 char *kwnames[] = {
17960 (char *) "self",(char *) "m_wheelRotation", NULL
17961 };
17962
17963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17965 if (SWIG_arg_fail(1)) SWIG_fail;
17966 {
17967 arg2 = (int)(SWIG_As_int(obj1));
17968 if (SWIG_arg_fail(2)) SWIG_fail;
17969 }
17970 if (arg1) (arg1)->m_wheelRotation = arg2;
17971
17972 Py_INCREF(Py_None); resultobj = Py_None;
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17980 PyObject *resultobj;
17981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17982 int result;
17983 PyObject * obj0 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 result = (int) ((arg1)->m_wheelRotation);
17992
17993 {
17994 resultobj = SWIG_From_int((int)(result));
17995 }
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj;
18004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18005 int arg2 ;
18006 PyObject * obj0 = 0 ;
18007 PyObject * obj1 = 0 ;
18008 char *kwnames[] = {
18009 (char *) "self",(char *) "m_wheelDelta", NULL
18010 };
18011
18012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(1)) SWIG_fail;
18015 {
18016 arg2 = (int)(SWIG_As_int(obj1));
18017 if (SWIG_arg_fail(2)) SWIG_fail;
18018 }
18019 if (arg1) (arg1)->m_wheelDelta = arg2;
18020
18021 Py_INCREF(Py_None); resultobj = Py_None;
18022 return resultobj;
18023 fail:
18024 return NULL;
18025 }
18026
18027
18028 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj;
18030 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18031 int result;
18032 PyObject * obj0 = 0 ;
18033 char *kwnames[] = {
18034 (char *) "self", NULL
18035 };
18036
18037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18039 if (SWIG_arg_fail(1)) SWIG_fail;
18040 result = (int) ((arg1)->m_wheelDelta);
18041
18042 {
18043 resultobj = SWIG_From_int((int)(result));
18044 }
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18054 int arg2 ;
18055 PyObject * obj0 = 0 ;
18056 PyObject * obj1 = 0 ;
18057 char *kwnames[] = {
18058 (char *) "self",(char *) "m_linesPerAction", NULL
18059 };
18060
18061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18063 if (SWIG_arg_fail(1)) SWIG_fail;
18064 {
18065 arg2 = (int)(SWIG_As_int(obj1));
18066 if (SWIG_arg_fail(2)) SWIG_fail;
18067 }
18068 if (arg1) (arg1)->m_linesPerAction = arg2;
18069
18070 Py_INCREF(Py_None); resultobj = Py_None;
18071 return resultobj;
18072 fail:
18073 return NULL;
18074 }
18075
18076
18077 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj;
18079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18080 int result;
18081 PyObject * obj0 = 0 ;
18082 char *kwnames[] = {
18083 (char *) "self", NULL
18084 };
18085
18086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18088 if (SWIG_arg_fail(1)) SWIG_fail;
18089 result = (int) ((arg1)->m_linesPerAction);
18090
18091 {
18092 resultobj = SWIG_From_int((int)(result));
18093 }
18094 return resultobj;
18095 fail:
18096 return NULL;
18097 }
18098
18099
18100 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18101 PyObject *obj;
18102 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18103 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18104 Py_INCREF(obj);
18105 return Py_BuildValue((char *)"");
18106 }
18107 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj;
18109 int arg1 = (int) 0 ;
18110 int arg2 = (int) 0 ;
18111 wxSetCursorEvent *result;
18112 PyObject * obj0 = 0 ;
18113 PyObject * obj1 = 0 ;
18114 char *kwnames[] = {
18115 (char *) "x",(char *) "y", NULL
18116 };
18117
18118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18119 if (obj0) {
18120 {
18121 arg1 = (int)(SWIG_As_int(obj0));
18122 if (SWIG_arg_fail(1)) SWIG_fail;
18123 }
18124 }
18125 if (obj1) {
18126 {
18127 arg2 = (int)(SWIG_As_int(obj1));
18128 if (SWIG_arg_fail(2)) SWIG_fail;
18129 }
18130 }
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18134
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj;
18147 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18148 int result;
18149 PyObject * obj0 = 0 ;
18150 char *kwnames[] = {
18151 (char *) "self", NULL
18152 };
18153
18154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18156 if (SWIG_arg_fail(1)) SWIG_fail;
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18160
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 {
18165 resultobj = SWIG_From_int((int)(result));
18166 }
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18174 PyObject *resultobj;
18175 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18176 int result;
18177 PyObject * obj0 = 0 ;
18178 char *kwnames[] = {
18179 (char *) "self", NULL
18180 };
18181
18182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18184 if (SWIG_arg_fail(1)) SWIG_fail;
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18188
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 {
18193 resultobj = SWIG_From_int((int)(result));
18194 }
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj;
18203 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18204 wxCursor *arg2 = 0 ;
18205 PyObject * obj0 = 0 ;
18206 PyObject * obj1 = 0 ;
18207 char *kwnames[] = {
18208 (char *) "self",(char *) "cursor", NULL
18209 };
18210
18211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18213 if (SWIG_arg_fail(1)) SWIG_fail;
18214 {
18215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18216 if (SWIG_arg_fail(2)) SWIG_fail;
18217 if (arg2 == NULL) {
18218 SWIG_null_ref("wxCursor");
18219 }
18220 if (SWIG_arg_fail(2)) SWIG_fail;
18221 }
18222 {
18223 PyThreadState* __tstate = wxPyBeginAllowThreads();
18224 (arg1)->SetCursor((wxCursor const &)*arg2);
18225
18226 wxPyEndAllowThreads(__tstate);
18227 if (PyErr_Occurred()) SWIG_fail;
18228 }
18229 Py_INCREF(Py_None); resultobj = Py_None;
18230 return resultobj;
18231 fail:
18232 return NULL;
18233 }
18234
18235
18236 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18237 PyObject *resultobj;
18238 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18239 wxCursor *result;
18240 PyObject * obj0 = 0 ;
18241 char *kwnames[] = {
18242 (char *) "self", NULL
18243 };
18244
18245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18247 if (SWIG_arg_fail(1)) SWIG_fail;
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 {
18251 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18252 result = (wxCursor *) &_result_ref;
18253 }
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 {
18259 wxCursor* resultptr = new wxCursor(*result);
18260 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18261 }
18262 return resultobj;
18263 fail:
18264 return NULL;
18265 }
18266
18267
18268 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18269 PyObject *resultobj;
18270 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18271 bool result;
18272 PyObject * obj0 = 0 ;
18273 char *kwnames[] = {
18274 (char *) "self", NULL
18275 };
18276
18277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 {
18288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18289 }
18290 return resultobj;
18291 fail:
18292 return NULL;
18293 }
18294
18295
18296 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18297 PyObject *obj;
18298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18299 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18300 Py_INCREF(obj);
18301 return Py_BuildValue((char *)"");
18302 }
18303 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj;
18305 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18306 wxKeyEvent *result;
18307 PyObject * obj0 = 0 ;
18308 char *kwnames[] = {
18309 (char *) "keyType", NULL
18310 };
18311
18312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18313 if (obj0) {
18314 {
18315 arg1 = (wxEventType)(SWIG_As_int(obj0));
18316 if (SWIG_arg_fail(1)) SWIG_fail;
18317 }
18318 }
18319 {
18320 PyThreadState* __tstate = wxPyBeginAllowThreads();
18321 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18322
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18334 PyObject *resultobj;
18335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18336 bool result;
18337 PyObject * obj0 = 0 ;
18338 char *kwnames[] = {
18339 (char *) "self", NULL
18340 };
18341
18342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18344 if (SWIG_arg_fail(1)) SWIG_fail;
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18348
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 {
18353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18354 }
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj;
18363 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18364 bool result;
18365 PyObject * obj0 = 0 ;
18366 char *kwnames[] = {
18367 (char *) "self", NULL
18368 };
18369
18370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18372 if (SWIG_arg_fail(1)) SWIG_fail;
18373 {
18374 PyThreadState* __tstate = wxPyBeginAllowThreads();
18375 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18376
18377 wxPyEndAllowThreads(__tstate);
18378 if (PyErr_Occurred()) SWIG_fail;
18379 }
18380 {
18381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18382 }
18383 return resultobj;
18384 fail:
18385 return NULL;
18386 }
18387
18388
18389 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18390 PyObject *resultobj;
18391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18392 bool result;
18393 PyObject * obj0 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18404
18405 wxPyEndAllowThreads(__tstate);
18406 if (PyErr_Occurred()) SWIG_fail;
18407 }
18408 {
18409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18410 }
18411 return resultobj;
18412 fail:
18413 return NULL;
18414 }
18415
18416
18417 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18418 PyObject *resultobj;
18419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18420 bool result;
18421 PyObject * obj0 = 0 ;
18422 char *kwnames[] = {
18423 (char *) "self", NULL
18424 };
18425
18426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18428 if (SWIG_arg_fail(1)) SWIG_fail;
18429 {
18430 PyThreadState* __tstate = wxPyBeginAllowThreads();
18431 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18432
18433 wxPyEndAllowThreads(__tstate);
18434 if (PyErr_Occurred()) SWIG_fail;
18435 }
18436 {
18437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18438 }
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18446 PyObject *resultobj;
18447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18448 bool result;
18449 PyObject * obj0 = 0 ;
18450 char *kwnames[] = {
18451 (char *) "self", NULL
18452 };
18453
18454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18456 if (SWIG_arg_fail(1)) SWIG_fail;
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18460
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 {
18465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18466 }
18467 return resultobj;
18468 fail:
18469 return NULL;
18470 }
18471
18472
18473 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18474 PyObject *resultobj;
18475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18476 bool result;
18477 PyObject * obj0 = 0 ;
18478 char *kwnames[] = {
18479 (char *) "self", NULL
18480 };
18481
18482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18484 if (SWIG_arg_fail(1)) SWIG_fail;
18485 {
18486 PyThreadState* __tstate = wxPyBeginAllowThreads();
18487 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18488
18489 wxPyEndAllowThreads(__tstate);
18490 if (PyErr_Occurred()) SWIG_fail;
18491 }
18492 {
18493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18504 int result;
18505 PyObject * obj0 = 0 ;
18506 char *kwnames[] = {
18507 (char *) "self", NULL
18508 };
18509
18510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18512 if (SWIG_arg_fail(1)) SWIG_fail;
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18516
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 {
18521 resultobj = SWIG_From_int((int)(result));
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj;
18531 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18532 int result;
18533 PyObject * obj0 = 0 ;
18534 char *kwnames[] = {
18535 (char *) "self", NULL
18536 };
18537
18538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18540 if (SWIG_arg_fail(1)) SWIG_fail;
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18544
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 {
18549 resultobj = SWIG_From_int((int)(result));
18550 }
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj;
18559 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18560 unsigned int result;
18561 PyObject * obj0 = 0 ;
18562 char *kwnames[] = {
18563 (char *) "self", NULL
18564 };
18565
18566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18568 if (SWIG_arg_fail(1)) SWIG_fail;
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18572
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 {
18577 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18578 }
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj;
18587 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18588 unsigned int result;
18589 PyObject * obj0 = 0 ;
18590 char *kwnames[] = {
18591 (char *) "self", NULL
18592 };
18593
18594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18596 if (SWIG_arg_fail(1)) SWIG_fail;
18597 {
18598 PyThreadState* __tstate = wxPyBeginAllowThreads();
18599 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18600
18601 wxPyEndAllowThreads(__tstate);
18602 if (PyErr_Occurred()) SWIG_fail;
18603 }
18604 {
18605 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18606 }
18607 return resultobj;
18608 fail:
18609 return NULL;
18610 }
18611
18612
18613 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18614 PyObject *resultobj;
18615 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18616 wxPoint result;
18617 PyObject * obj0 = 0 ;
18618 char *kwnames[] = {
18619 (char *) "self", NULL
18620 };
18621
18622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18624 if (SWIG_arg_fail(1)) SWIG_fail;
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 result = (arg1)->GetPosition();
18628
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 {
18633 wxPoint * resultptr;
18634 resultptr = new wxPoint((wxPoint &)(result));
18635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18636 }
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18644 PyObject *resultobj;
18645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18646 long *arg2 = (long *) 0 ;
18647 long *arg3 = (long *) 0 ;
18648 long temp2 ;
18649 int res2 = 0 ;
18650 long temp3 ;
18651 int res3 = 0 ;
18652 PyObject * obj0 = 0 ;
18653 char *kwnames[] = {
18654 (char *) "self", NULL
18655 };
18656
18657 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18658 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18661 if (SWIG_arg_fail(1)) SWIG_fail;
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 (arg1)->GetPosition(arg2,arg3);
18665
18666 wxPyEndAllowThreads(__tstate);
18667 if (PyErr_Occurred()) SWIG_fail;
18668 }
18669 Py_INCREF(Py_None); resultobj = Py_None;
18670 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18671 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18672 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18673 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj;
18682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18683 int result;
18684 PyObject * obj0 = 0 ;
18685 char *kwnames[] = {
18686 (char *) "self", NULL
18687 };
18688
18689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18691 if (SWIG_arg_fail(1)) SWIG_fail;
18692 {
18693 PyThreadState* __tstate = wxPyBeginAllowThreads();
18694 result = (int)((wxKeyEvent const *)arg1)->GetX();
18695
18696 wxPyEndAllowThreads(__tstate);
18697 if (PyErr_Occurred()) SWIG_fail;
18698 }
18699 {
18700 resultobj = SWIG_From_int((int)(result));
18701 }
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18709 PyObject *resultobj;
18710 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18711 int result;
18712 PyObject * obj0 = 0 ;
18713 char *kwnames[] = {
18714 (char *) "self", NULL
18715 };
18716
18717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18719 if (SWIG_arg_fail(1)) SWIG_fail;
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 result = (int)((wxKeyEvent const *)arg1)->GetY();
18723
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 {
18728 resultobj = SWIG_From_int((int)(result));
18729 }
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj;
18738 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18739 int arg2 ;
18740 PyObject * obj0 = 0 ;
18741 PyObject * obj1 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self",(char *) "m_x", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 {
18750 arg2 = (int)(SWIG_As_int(obj1));
18751 if (SWIG_arg_fail(2)) SWIG_fail;
18752 }
18753 if (arg1) (arg1)->m_x = arg2;
18754
18755 Py_INCREF(Py_None); resultobj = Py_None;
18756 return resultobj;
18757 fail:
18758 return NULL;
18759 }
18760
18761
18762 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj;
18764 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18765 int result;
18766 PyObject * obj0 = 0 ;
18767 char *kwnames[] = {
18768 (char *) "self", NULL
18769 };
18770
18771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18773 if (SWIG_arg_fail(1)) SWIG_fail;
18774 result = (int) ((arg1)->m_x);
18775
18776 {
18777 resultobj = SWIG_From_int((int)(result));
18778 }
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18786 PyObject *resultobj;
18787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18788 int arg2 ;
18789 PyObject * obj0 = 0 ;
18790 PyObject * obj1 = 0 ;
18791 char *kwnames[] = {
18792 (char *) "self",(char *) "m_y", NULL
18793 };
18794
18795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18797 if (SWIG_arg_fail(1)) SWIG_fail;
18798 {
18799 arg2 = (int)(SWIG_As_int(obj1));
18800 if (SWIG_arg_fail(2)) SWIG_fail;
18801 }
18802 if (arg1) (arg1)->m_y = arg2;
18803
18804 Py_INCREF(Py_None); resultobj = Py_None;
18805 return resultobj;
18806 fail:
18807 return NULL;
18808 }
18809
18810
18811 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18814 int result;
18815 PyObject * obj0 = 0 ;
18816 char *kwnames[] = {
18817 (char *) "self", NULL
18818 };
18819
18820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18822 if (SWIG_arg_fail(1)) SWIG_fail;
18823 result = (int) ((arg1)->m_y);
18824
18825 {
18826 resultobj = SWIG_From_int((int)(result));
18827 }
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18835 PyObject *resultobj;
18836 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18837 long arg2 ;
18838 PyObject * obj0 = 0 ;
18839 PyObject * obj1 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self",(char *) "m_keyCode", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 arg2 = (long)(SWIG_As_long(obj1));
18849 if (SWIG_arg_fail(2)) SWIG_fail;
18850 }
18851 if (arg1) (arg1)->m_keyCode = arg2;
18852
18853 Py_INCREF(Py_None); resultobj = Py_None;
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18861 PyObject *resultobj;
18862 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18863 long result;
18864 PyObject * obj0 = 0 ;
18865 char *kwnames[] = {
18866 (char *) "self", NULL
18867 };
18868
18869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18871 if (SWIG_arg_fail(1)) SWIG_fail;
18872 result = (long) ((arg1)->m_keyCode);
18873
18874 {
18875 resultobj = SWIG_From_long((long)(result));
18876 }
18877 return resultobj;
18878 fail:
18879 return NULL;
18880 }
18881
18882
18883 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18884 PyObject *resultobj;
18885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18886 bool arg2 ;
18887 PyObject * obj0 = 0 ;
18888 PyObject * obj1 = 0 ;
18889 char *kwnames[] = {
18890 (char *) "self",(char *) "m_controlDown", NULL
18891 };
18892
18893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18895 if (SWIG_arg_fail(1)) SWIG_fail;
18896 {
18897 arg2 = (bool)(SWIG_As_bool(obj1));
18898 if (SWIG_arg_fail(2)) SWIG_fail;
18899 }
18900 if (arg1) (arg1)->m_controlDown = arg2;
18901
18902 Py_INCREF(Py_None); resultobj = Py_None;
18903 return resultobj;
18904 fail:
18905 return NULL;
18906 }
18907
18908
18909 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18910 PyObject *resultobj;
18911 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18912 bool result;
18913 PyObject * obj0 = 0 ;
18914 char *kwnames[] = {
18915 (char *) "self", NULL
18916 };
18917
18918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18920 if (SWIG_arg_fail(1)) SWIG_fail;
18921 result = (bool) ((arg1)->m_controlDown);
18922
18923 {
18924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18925 }
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18935 bool arg2 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char *kwnames[] = {
18939 (char *) "self",(char *) "m_shiftDown", NULL
18940 };
18941
18942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18944 if (SWIG_arg_fail(1)) SWIG_fail;
18945 {
18946 arg2 = (bool)(SWIG_As_bool(obj1));
18947 if (SWIG_arg_fail(2)) SWIG_fail;
18948 }
18949 if (arg1) (arg1)->m_shiftDown = arg2;
18950
18951 Py_INCREF(Py_None); resultobj = Py_None;
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18959 PyObject *resultobj;
18960 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18961 bool result;
18962 PyObject * obj0 = 0 ;
18963 char *kwnames[] = {
18964 (char *) "self", NULL
18965 };
18966
18967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18969 if (SWIG_arg_fail(1)) SWIG_fail;
18970 result = (bool) ((arg1)->m_shiftDown);
18971
18972 {
18973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18974 }
18975 return resultobj;
18976 fail:
18977 return NULL;
18978 }
18979
18980
18981 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj;
18983 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18984 bool arg2 ;
18985 PyObject * obj0 = 0 ;
18986 PyObject * obj1 = 0 ;
18987 char *kwnames[] = {
18988 (char *) "self",(char *) "m_altDown", NULL
18989 };
18990
18991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18993 if (SWIG_arg_fail(1)) SWIG_fail;
18994 {
18995 arg2 = (bool)(SWIG_As_bool(obj1));
18996 if (SWIG_arg_fail(2)) SWIG_fail;
18997 }
18998 if (arg1) (arg1)->m_altDown = arg2;
18999
19000 Py_INCREF(Py_None); resultobj = Py_None;
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19008 PyObject *resultobj;
19009 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19010 bool result;
19011 PyObject * obj0 = 0 ;
19012 char *kwnames[] = {
19013 (char *) "self", NULL
19014 };
19015
19016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19018 if (SWIG_arg_fail(1)) SWIG_fail;
19019 result = (bool) ((arg1)->m_altDown);
19020
19021 {
19022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19023 }
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj;
19032 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19033 bool arg2 ;
19034 PyObject * obj0 = 0 ;
19035 PyObject * obj1 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "self",(char *) "m_metaDown", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19042 if (SWIG_arg_fail(1)) SWIG_fail;
19043 {
19044 arg2 = (bool)(SWIG_As_bool(obj1));
19045 if (SWIG_arg_fail(2)) SWIG_fail;
19046 }
19047 if (arg1) (arg1)->m_metaDown = arg2;
19048
19049 Py_INCREF(Py_None); resultobj = Py_None;
19050 return resultobj;
19051 fail:
19052 return NULL;
19053 }
19054
19055
19056 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19057 PyObject *resultobj;
19058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19059 bool result;
19060 PyObject * obj0 = 0 ;
19061 char *kwnames[] = {
19062 (char *) "self", NULL
19063 };
19064
19065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19067 if (SWIG_arg_fail(1)) SWIG_fail;
19068 result = (bool) ((arg1)->m_metaDown);
19069
19070 {
19071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19072 }
19073 return resultobj;
19074 fail:
19075 return NULL;
19076 }
19077
19078
19079 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19080 PyObject *resultobj;
19081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19082 bool arg2 ;
19083 PyObject * obj0 = 0 ;
19084 PyObject * obj1 = 0 ;
19085 char *kwnames[] = {
19086 (char *) "self",(char *) "m_scanCode", NULL
19087 };
19088
19089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19091 if (SWIG_arg_fail(1)) SWIG_fail;
19092 {
19093 arg2 = (bool)(SWIG_As_bool(obj1));
19094 if (SWIG_arg_fail(2)) SWIG_fail;
19095 }
19096 if (arg1) (arg1)->m_scanCode = arg2;
19097
19098 Py_INCREF(Py_None); resultobj = Py_None;
19099 return resultobj;
19100 fail:
19101 return NULL;
19102 }
19103
19104
19105 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj;
19107 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19108 bool result;
19109 PyObject * obj0 = 0 ;
19110 char *kwnames[] = {
19111 (char *) "self", NULL
19112 };
19113
19114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19116 if (SWIG_arg_fail(1)) SWIG_fail;
19117 result = (bool) ((arg1)->m_scanCode);
19118
19119 {
19120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19121 }
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19129 PyObject *resultobj;
19130 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19131 unsigned int arg2 ;
19132 PyObject * obj0 = 0 ;
19133 PyObject * obj1 = 0 ;
19134 char *kwnames[] = {
19135 (char *) "self",(char *) "m_rawCode", NULL
19136 };
19137
19138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19140 if (SWIG_arg_fail(1)) SWIG_fail;
19141 {
19142 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19143 if (SWIG_arg_fail(2)) SWIG_fail;
19144 }
19145 if (arg1) (arg1)->m_rawCode = arg2;
19146
19147 Py_INCREF(Py_None); resultobj = Py_None;
19148 return resultobj;
19149 fail:
19150 return NULL;
19151 }
19152
19153
19154 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19155 PyObject *resultobj;
19156 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19157 unsigned int result;
19158 PyObject * obj0 = 0 ;
19159 char *kwnames[] = {
19160 (char *) "self", NULL
19161 };
19162
19163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19165 if (SWIG_arg_fail(1)) SWIG_fail;
19166 result = (unsigned int) ((arg1)->m_rawCode);
19167
19168 {
19169 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19170 }
19171 return resultobj;
19172 fail:
19173 return NULL;
19174 }
19175
19176
19177 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19178 PyObject *resultobj;
19179 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19180 unsigned int arg2 ;
19181 PyObject * obj0 = 0 ;
19182 PyObject * obj1 = 0 ;
19183 char *kwnames[] = {
19184 (char *) "self",(char *) "m_rawFlags", NULL
19185 };
19186
19187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19189 if (SWIG_arg_fail(1)) SWIG_fail;
19190 {
19191 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19192 if (SWIG_arg_fail(2)) SWIG_fail;
19193 }
19194 if (arg1) (arg1)->m_rawFlags = arg2;
19195
19196 Py_INCREF(Py_None); resultobj = Py_None;
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19204 PyObject *resultobj;
19205 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19206 unsigned int result;
19207 PyObject * obj0 = 0 ;
19208 char *kwnames[] = {
19209 (char *) "self", NULL
19210 };
19211
19212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19214 if (SWIG_arg_fail(1)) SWIG_fail;
19215 result = (unsigned int) ((arg1)->m_rawFlags);
19216
19217 {
19218 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19219 }
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19227 PyObject *obj;
19228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19229 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19230 Py_INCREF(obj);
19231 return Py_BuildValue((char *)"");
19232 }
19233 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19234 PyObject *resultobj;
19235 wxSize const &arg1_defvalue = wxDefaultSize ;
19236 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19237 int arg2 = (int) 0 ;
19238 wxSizeEvent *result;
19239 wxSize temp1 ;
19240 PyObject * obj0 = 0 ;
19241 PyObject * obj1 = 0 ;
19242 char *kwnames[] = {
19243 (char *) "sz",(char *) "winid", NULL
19244 };
19245
19246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19247 if (obj0) {
19248 {
19249 arg1 = &temp1;
19250 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19251 }
19252 }
19253 if (obj1) {
19254 {
19255 arg2 = (int)(SWIG_As_int(obj1));
19256 if (SWIG_arg_fail(2)) SWIG_fail;
19257 }
19258 }
19259 {
19260 PyThreadState* __tstate = wxPyBeginAllowThreads();
19261 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19262
19263 wxPyEndAllowThreads(__tstate);
19264 if (PyErr_Occurred()) SWIG_fail;
19265 }
19266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19267 return resultobj;
19268 fail:
19269 return NULL;
19270 }
19271
19272
19273 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19274 PyObject *resultobj;
19275 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19276 wxSize result;
19277 PyObject * obj0 = 0 ;
19278 char *kwnames[] = {
19279 (char *) "self", NULL
19280 };
19281
19282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19284 if (SWIG_arg_fail(1)) SWIG_fail;
19285 {
19286 PyThreadState* __tstate = wxPyBeginAllowThreads();
19287 result = ((wxSizeEvent const *)arg1)->GetSize();
19288
19289 wxPyEndAllowThreads(__tstate);
19290 if (PyErr_Occurred()) SWIG_fail;
19291 }
19292 {
19293 wxSize * resultptr;
19294 resultptr = new wxSize((wxSize &)(result));
19295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19296 }
19297 return resultobj;
19298 fail:
19299 return NULL;
19300 }
19301
19302
19303 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19304 PyObject *resultobj;
19305 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19306 wxRect result;
19307 PyObject * obj0 = 0 ;
19308 char *kwnames[] = {
19309 (char *) "self", NULL
19310 };
19311
19312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19314 if (SWIG_arg_fail(1)) SWIG_fail;
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = ((wxSizeEvent const *)arg1)->GetRect();
19318
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 {
19323 wxRect * resultptr;
19324 resultptr = new wxRect((wxRect &)(result));
19325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19326 }
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj;
19335 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19336 wxRect arg2 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "self",(char *) "rect", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 {
19347 wxRect * argp;
19348 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19349 if (SWIG_arg_fail(2)) SWIG_fail;
19350 if (argp == NULL) {
19351 SWIG_null_ref("wxRect");
19352 }
19353 if (SWIG_arg_fail(2)) SWIG_fail;
19354 arg2 = *argp;
19355 }
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 (arg1)->SetRect(arg2);
19359
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 Py_INCREF(Py_None); resultobj = Py_None;
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj;
19372 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19373 wxSize arg2 ;
19374 PyObject * obj0 = 0 ;
19375 PyObject * obj1 = 0 ;
19376 char *kwnames[] = {
19377 (char *) "self",(char *) "size", NULL
19378 };
19379
19380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19382 if (SWIG_arg_fail(1)) SWIG_fail;
19383 {
19384 wxSize * argp;
19385 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19386 if (SWIG_arg_fail(2)) SWIG_fail;
19387 if (argp == NULL) {
19388 SWIG_null_ref("wxSize");
19389 }
19390 if (SWIG_arg_fail(2)) SWIG_fail;
19391 arg2 = *argp;
19392 }
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 wxSizeEvent_SetSize(arg1,arg2);
19396
19397 wxPyEndAllowThreads(__tstate);
19398 if (PyErr_Occurred()) SWIG_fail;
19399 }
19400 Py_INCREF(Py_None); resultobj = Py_None;
19401 return resultobj;
19402 fail:
19403 return NULL;
19404 }
19405
19406
19407 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19408 PyObject *resultobj;
19409 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19410 wxSize *arg2 = (wxSize *) 0 ;
19411 PyObject * obj0 = 0 ;
19412 PyObject * obj1 = 0 ;
19413 char *kwnames[] = {
19414 (char *) "self",(char *) "m_size", NULL
19415 };
19416
19417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19419 if (SWIG_arg_fail(1)) SWIG_fail;
19420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19421 if (SWIG_arg_fail(2)) SWIG_fail;
19422 if (arg1) (arg1)->m_size = *arg2;
19423
19424 Py_INCREF(Py_None); resultobj = Py_None;
19425 return resultobj;
19426 fail:
19427 return NULL;
19428 }
19429
19430
19431 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19432 PyObject *resultobj;
19433 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19434 wxSize *result;
19435 PyObject * obj0 = 0 ;
19436 char *kwnames[] = {
19437 (char *) "self", NULL
19438 };
19439
19440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19442 if (SWIG_arg_fail(1)) SWIG_fail;
19443 result = (wxSize *)& ((arg1)->m_size);
19444
19445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19446 return resultobj;
19447 fail:
19448 return NULL;
19449 }
19450
19451
19452 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj;
19454 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19455 wxRect *arg2 = (wxRect *) 0 ;
19456 PyObject * obj0 = 0 ;
19457 PyObject * obj1 = 0 ;
19458 char *kwnames[] = {
19459 (char *) "self",(char *) "m_rect", NULL
19460 };
19461
19462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19464 if (SWIG_arg_fail(1)) SWIG_fail;
19465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19466 if (SWIG_arg_fail(2)) SWIG_fail;
19467 if (arg1) (arg1)->m_rect = *arg2;
19468
19469 Py_INCREF(Py_None); resultobj = Py_None;
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19477 PyObject *resultobj;
19478 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19479 wxRect *result;
19480 PyObject * obj0 = 0 ;
19481 char *kwnames[] = {
19482 (char *) "self", NULL
19483 };
19484
19485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19487 if (SWIG_arg_fail(1)) SWIG_fail;
19488 result = (wxRect *)& ((arg1)->m_rect);
19489
19490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19491 return resultobj;
19492 fail:
19493 return NULL;
19494 }
19495
19496
19497 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19498 PyObject *obj;
19499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19500 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19501 Py_INCREF(obj);
19502 return Py_BuildValue((char *)"");
19503 }
19504 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj;
19506 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19507 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19508 int arg2 = (int) 0 ;
19509 wxMoveEvent *result;
19510 wxPoint temp1 ;
19511 PyObject * obj0 = 0 ;
19512 PyObject * obj1 = 0 ;
19513 char *kwnames[] = {
19514 (char *) "pos",(char *) "winid", NULL
19515 };
19516
19517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19518 if (obj0) {
19519 {
19520 arg1 = &temp1;
19521 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19522 }
19523 }
19524 if (obj1) {
19525 {
19526 arg2 = (int)(SWIG_As_int(obj1));
19527 if (SWIG_arg_fail(2)) SWIG_fail;
19528 }
19529 }
19530 {
19531 PyThreadState* __tstate = wxPyBeginAllowThreads();
19532 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19533
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19545 PyObject *resultobj;
19546 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19547 wxPoint result;
19548 PyObject * obj0 = 0 ;
19549 char *kwnames[] = {
19550 (char *) "self", NULL
19551 };
19552
19553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19555 if (SWIG_arg_fail(1)) SWIG_fail;
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = ((wxMoveEvent const *)arg1)->GetPosition();
19559
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 {
19564 wxPoint * resultptr;
19565 resultptr = new wxPoint((wxPoint &)(result));
19566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19567 }
19568 return resultobj;
19569 fail:
19570 return NULL;
19571 }
19572
19573
19574 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19575 PyObject *resultobj;
19576 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19577 wxRect result;
19578 PyObject * obj0 = 0 ;
19579 char *kwnames[] = {
19580 (char *) "self", NULL
19581 };
19582
19583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19585 if (SWIG_arg_fail(1)) SWIG_fail;
19586 {
19587 PyThreadState* __tstate = wxPyBeginAllowThreads();
19588 result = ((wxMoveEvent const *)arg1)->GetRect();
19589
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 {
19594 wxRect * resultptr;
19595 resultptr = new wxRect((wxRect &)(result));
19596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19597 }
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19607 wxRect *arg2 = 0 ;
19608 wxRect temp2 ;
19609 PyObject * obj0 = 0 ;
19610 PyObject * obj1 = 0 ;
19611 char *kwnames[] = {
19612 (char *) "self",(char *) "rect", NULL
19613 };
19614
19615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19617 if (SWIG_arg_fail(1)) SWIG_fail;
19618 {
19619 arg2 = &temp2;
19620 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19621 }
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 (arg1)->SetRect((wxRect const &)*arg2);
19625
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 Py_INCREF(Py_None); resultobj = Py_None;
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj;
19638 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19639 wxPoint *arg2 = 0 ;
19640 wxPoint temp2 ;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "self",(char *) "pos", NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19649 if (SWIG_arg_fail(1)) SWIG_fail;
19650 {
19651 arg2 = &temp2;
19652 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19653 }
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 (arg1)->SetPosition((wxPoint const &)*arg2);
19657
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 Py_INCREF(Py_None); resultobj = Py_None;
19662 return resultobj;
19663 fail:
19664 return NULL;
19665 }
19666
19667
19668 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19669 PyObject *obj;
19670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19671 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19672 Py_INCREF(obj);
19673 return Py_BuildValue((char *)"");
19674 }
19675 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj;
19677 int arg1 = (int) 0 ;
19678 wxPaintEvent *result;
19679 PyObject * obj0 = 0 ;
19680 char *kwnames[] = {
19681 (char *) "Id", NULL
19682 };
19683
19684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19685 if (obj0) {
19686 {
19687 arg1 = (int)(SWIG_As_int(obj0));
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 }
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19694
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19706 PyObject *obj;
19707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19708 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19709 Py_INCREF(obj);
19710 return Py_BuildValue((char *)"");
19711 }
19712 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19713 PyObject *resultobj;
19714 int arg1 = (int) 0 ;
19715 wxNcPaintEvent *result;
19716 PyObject * obj0 = 0 ;
19717 char *kwnames[] = {
19718 (char *) "winid", NULL
19719 };
19720
19721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19722 if (obj0) {
19723 {
19724 arg1 = (int)(SWIG_As_int(obj0));
19725 if (SWIG_arg_fail(1)) SWIG_fail;
19726 }
19727 }
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19731
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19743 PyObject *obj;
19744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19745 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19746 Py_INCREF(obj);
19747 return Py_BuildValue((char *)"");
19748 }
19749 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj;
19751 int arg1 = (int) 0 ;
19752 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19753 wxEraseEvent *result;
19754 PyObject * obj0 = 0 ;
19755 PyObject * obj1 = 0 ;
19756 char *kwnames[] = {
19757 (char *) "Id",(char *) "dc", NULL
19758 };
19759
19760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19761 if (obj0) {
19762 {
19763 arg1 = (int)(SWIG_As_int(obj0));
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 }
19766 }
19767 if (obj1) {
19768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19769 if (SWIG_arg_fail(2)) SWIG_fail;
19770 }
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19774
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19786 PyObject *resultobj;
19787 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19788 wxDC *result;
19789 PyObject * obj0 = 0 ;
19790 char *kwnames[] = {
19791 (char *) "self", NULL
19792 };
19793
19794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19796 if (SWIG_arg_fail(1)) SWIG_fail;
19797 {
19798 PyThreadState* __tstate = wxPyBeginAllowThreads();
19799 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19800
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 {
19805 resultobj = wxPyMake_wxObject(result, 0);
19806 }
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19814 PyObject *obj;
19815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19816 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19817 Py_INCREF(obj);
19818 return Py_BuildValue((char *)"");
19819 }
19820 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19821 PyObject *resultobj;
19822 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19823 int arg2 = (int) 0 ;
19824 wxFocusEvent *result;
19825 PyObject * obj0 = 0 ;
19826 PyObject * obj1 = 0 ;
19827 char *kwnames[] = {
19828 (char *) "type",(char *) "winid", NULL
19829 };
19830
19831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19832 if (obj0) {
19833 {
19834 arg1 = (wxEventType)(SWIG_As_int(obj0));
19835 if (SWIG_arg_fail(1)) SWIG_fail;
19836 }
19837 }
19838 if (obj1) {
19839 {
19840 arg2 = (int)(SWIG_As_int(obj1));
19841 if (SWIG_arg_fail(2)) SWIG_fail;
19842 }
19843 }
19844 {
19845 PyThreadState* __tstate = wxPyBeginAllowThreads();
19846 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19847
19848 wxPyEndAllowThreads(__tstate);
19849 if (PyErr_Occurred()) SWIG_fail;
19850 }
19851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19852 return resultobj;
19853 fail:
19854 return NULL;
19855 }
19856
19857
19858 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19859 PyObject *resultobj;
19860 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19861 wxWindow *result;
19862 PyObject * obj0 = 0 ;
19863 char *kwnames[] = {
19864 (char *) "self", NULL
19865 };
19866
19867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19869 if (SWIG_arg_fail(1)) SWIG_fail;
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19873
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 {
19878 resultobj = wxPyMake_wxObject(result, 0);
19879 }
19880 return resultobj;
19881 fail:
19882 return NULL;
19883 }
19884
19885
19886 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19887 PyObject *resultobj;
19888 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19889 wxWindow *arg2 = (wxWindow *) 0 ;
19890 PyObject * obj0 = 0 ;
19891 PyObject * obj1 = 0 ;
19892 char *kwnames[] = {
19893 (char *) "self",(char *) "win", NULL
19894 };
19895
19896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19898 if (SWIG_arg_fail(1)) SWIG_fail;
19899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(2)) SWIG_fail;
19901 {
19902 PyThreadState* __tstate = wxPyBeginAllowThreads();
19903 (arg1)->SetWindow(arg2);
19904
19905 wxPyEndAllowThreads(__tstate);
19906 if (PyErr_Occurred()) SWIG_fail;
19907 }
19908 Py_INCREF(Py_None); resultobj = Py_None;
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19916 PyObject *obj;
19917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19918 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19919 Py_INCREF(obj);
19920 return Py_BuildValue((char *)"");
19921 }
19922 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19923 PyObject *resultobj;
19924 wxWindow *arg1 = (wxWindow *) NULL ;
19925 wxChildFocusEvent *result;
19926 PyObject * obj0 = 0 ;
19927 char *kwnames[] = {
19928 (char *) "win", NULL
19929 };
19930
19931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19932 if (obj0) {
19933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19934 if (SWIG_arg_fail(1)) SWIG_fail;
19935 }
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19939
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19944 return resultobj;
19945 fail:
19946 return NULL;
19947 }
19948
19949
19950 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19951 PyObject *resultobj;
19952 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19953 wxWindow *result;
19954 PyObject * obj0 = 0 ;
19955 char *kwnames[] = {
19956 (char *) "self", NULL
19957 };
19958
19959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19961 if (SWIG_arg_fail(1)) SWIG_fail;
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 {
19970 resultobj = wxPyMake_wxObject(result, 0);
19971 }
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19979 PyObject *obj;
19980 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19981 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19982 Py_INCREF(obj);
19983 return Py_BuildValue((char *)"");
19984 }
19985 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19986 PyObject *resultobj;
19987 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19988 bool arg2 = (bool) true ;
19989 int arg3 = (int) 0 ;
19990 wxActivateEvent *result;
19991 PyObject * obj0 = 0 ;
19992 PyObject * obj1 = 0 ;
19993 PyObject * obj2 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "type",(char *) "active",(char *) "Id", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19999 if (obj0) {
20000 {
20001 arg1 = (wxEventType)(SWIG_As_int(obj0));
20002 if (SWIG_arg_fail(1)) SWIG_fail;
20003 }
20004 }
20005 if (obj1) {
20006 {
20007 arg2 = (bool)(SWIG_As_bool(obj1));
20008 if (SWIG_arg_fail(2)) SWIG_fail;
20009 }
20010 }
20011 if (obj2) {
20012 {
20013 arg3 = (int)(SWIG_As_int(obj2));
20014 if (SWIG_arg_fail(3)) SWIG_fail;
20015 }
20016 }
20017 {
20018 PyThreadState* __tstate = wxPyBeginAllowThreads();
20019 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20020
20021 wxPyEndAllowThreads(__tstate);
20022 if (PyErr_Occurred()) SWIG_fail;
20023 }
20024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20025 return resultobj;
20026 fail:
20027 return NULL;
20028 }
20029
20030
20031 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20032 PyObject *resultobj;
20033 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20034 bool result;
20035 PyObject * obj0 = 0 ;
20036 char *kwnames[] = {
20037 (char *) "self", NULL
20038 };
20039
20040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20042 if (SWIG_arg_fail(1)) SWIG_fail;
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20046
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 {
20051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20052 }
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20060 PyObject *obj;
20061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20062 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20063 Py_INCREF(obj);
20064 return Py_BuildValue((char *)"");
20065 }
20066 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj;
20068 int arg1 = (int) 0 ;
20069 wxInitDialogEvent *result;
20070 PyObject * obj0 = 0 ;
20071 char *kwnames[] = {
20072 (char *) "Id", NULL
20073 };
20074
20075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20076 if (obj0) {
20077 {
20078 arg1 = (int)(SWIG_As_int(obj0));
20079 if (SWIG_arg_fail(1)) SWIG_fail;
20080 }
20081 }
20082 {
20083 PyThreadState* __tstate = wxPyBeginAllowThreads();
20084 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20085
20086 wxPyEndAllowThreads(__tstate);
20087 if (PyErr_Occurred()) SWIG_fail;
20088 }
20089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20090 return resultobj;
20091 fail:
20092 return NULL;
20093 }
20094
20095
20096 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20097 PyObject *obj;
20098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20099 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20100 Py_INCREF(obj);
20101 return Py_BuildValue((char *)"");
20102 }
20103 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20104 PyObject *resultobj;
20105 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20106 int arg2 = (int) 0 ;
20107 wxMenu *arg3 = (wxMenu *) NULL ;
20108 wxMenuEvent *result;
20109 PyObject * obj0 = 0 ;
20110 PyObject * obj1 = 0 ;
20111 PyObject * obj2 = 0 ;
20112 char *kwnames[] = {
20113 (char *) "type",(char *) "winid",(char *) "menu", NULL
20114 };
20115
20116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20117 if (obj0) {
20118 {
20119 arg1 = (wxEventType)(SWIG_As_int(obj0));
20120 if (SWIG_arg_fail(1)) SWIG_fail;
20121 }
20122 }
20123 if (obj1) {
20124 {
20125 arg2 = (int)(SWIG_As_int(obj1));
20126 if (SWIG_arg_fail(2)) SWIG_fail;
20127 }
20128 }
20129 if (obj2) {
20130 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20131 if (SWIG_arg_fail(3)) SWIG_fail;
20132 }
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20136
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20148 PyObject *resultobj;
20149 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20150 int result;
20151 PyObject * obj0 = 0 ;
20152 char *kwnames[] = {
20153 (char *) "self", NULL
20154 };
20155
20156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20158 if (SWIG_arg_fail(1)) SWIG_fail;
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20162
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 resultobj = SWIG_From_int((int)(result));
20168 }
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj;
20177 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20178 bool result;
20179 PyObject * obj0 = 0 ;
20180 char *kwnames[] = {
20181 (char *) "self", NULL
20182 };
20183
20184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20186 if (SWIG_arg_fail(1)) SWIG_fail;
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20190
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj;
20205 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20206 wxMenu *result;
20207 PyObject * obj0 = 0 ;
20208 char *kwnames[] = {
20209 (char *) "self", NULL
20210 };
20211
20212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20214 if (SWIG_arg_fail(1)) SWIG_fail;
20215 {
20216 PyThreadState* __tstate = wxPyBeginAllowThreads();
20217 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20218
20219 wxPyEndAllowThreads(__tstate);
20220 if (PyErr_Occurred()) SWIG_fail;
20221 }
20222 {
20223 resultobj = wxPyMake_wxObject(result, 0);
20224 }
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20232 PyObject *obj;
20233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20234 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20235 Py_INCREF(obj);
20236 return Py_BuildValue((char *)"");
20237 }
20238 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj;
20240 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20241 int arg2 = (int) 0 ;
20242 wxCloseEvent *result;
20243 PyObject * obj0 = 0 ;
20244 PyObject * obj1 = 0 ;
20245 char *kwnames[] = {
20246 (char *) "type",(char *) "winid", NULL
20247 };
20248
20249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20250 if (obj0) {
20251 {
20252 arg1 = (wxEventType)(SWIG_As_int(obj0));
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 }
20255 }
20256 if (obj1) {
20257 {
20258 arg2 = (int)(SWIG_As_int(obj1));
20259 if (SWIG_arg_fail(2)) SWIG_fail;
20260 }
20261 }
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20265
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20279 bool arg2 ;
20280 PyObject * obj0 = 0 ;
20281 PyObject * obj1 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self",(char *) "logOff", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 arg2 = (bool)(SWIG_As_bool(obj1));
20291 if (SWIG_arg_fail(2)) SWIG_fail;
20292 }
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 (arg1)->SetLoggingOff(arg2);
20296
20297 wxPyEndAllowThreads(__tstate);
20298 if (PyErr_Occurred()) SWIG_fail;
20299 }
20300 Py_INCREF(Py_None); resultobj = Py_None;
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20308 PyObject *resultobj;
20309 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20310 bool result;
20311 PyObject * obj0 = 0 ;
20312 char *kwnames[] = {
20313 (char *) "self", NULL
20314 };
20315
20316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20318 if (SWIG_arg_fail(1)) SWIG_fail;
20319 {
20320 PyThreadState* __tstate = wxPyBeginAllowThreads();
20321 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20322
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 {
20327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20328 }
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20336 PyObject *resultobj;
20337 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20338 bool arg2 = (bool) true ;
20339 PyObject * obj0 = 0 ;
20340 PyObject * obj1 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self",(char *) "veto", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 if (obj1) {
20349 {
20350 arg2 = (bool)(SWIG_As_bool(obj1));
20351 if (SWIG_arg_fail(2)) SWIG_fail;
20352 }
20353 }
20354 {
20355 PyThreadState* __tstate = wxPyBeginAllowThreads();
20356 (arg1)->Veto(arg2);
20357
20358 wxPyEndAllowThreads(__tstate);
20359 if (PyErr_Occurred()) SWIG_fail;
20360 }
20361 Py_INCREF(Py_None); resultobj = Py_None;
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj;
20370 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20371 bool arg2 ;
20372 PyObject * obj0 = 0 ;
20373 PyObject * obj1 = 0 ;
20374 char *kwnames[] = {
20375 (char *) "self",(char *) "canVeto", NULL
20376 };
20377
20378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20380 if (SWIG_arg_fail(1)) SWIG_fail;
20381 {
20382 arg2 = (bool)(SWIG_As_bool(obj1));
20383 if (SWIG_arg_fail(2)) SWIG_fail;
20384 }
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 (arg1)->SetCanVeto(arg2);
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 Py_INCREF(Py_None); resultobj = Py_None;
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20400 PyObject *resultobj;
20401 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20402 bool result;
20403 PyObject * obj0 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "self", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20410 if (SWIG_arg_fail(1)) SWIG_fail;
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20414
20415 wxPyEndAllowThreads(__tstate);
20416 if (PyErr_Occurred()) SWIG_fail;
20417 }
20418 {
20419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20430 bool result;
20431 PyObject * obj0 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "self", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20438 if (SWIG_arg_fail(1)) SWIG_fail;
20439 {
20440 PyThreadState* __tstate = wxPyBeginAllowThreads();
20441 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20442
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 {
20447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20448 }
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20456 PyObject *obj;
20457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20458 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20459 Py_INCREF(obj);
20460 return Py_BuildValue((char *)"");
20461 }
20462 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj;
20464 int arg1 = (int) 0 ;
20465 bool arg2 = (bool) false ;
20466 wxShowEvent *result;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "winid",(char *) "show", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20474 if (obj0) {
20475 {
20476 arg1 = (int)(SWIG_As_int(obj0));
20477 if (SWIG_arg_fail(1)) SWIG_fail;
20478 }
20479 }
20480 if (obj1) {
20481 {
20482 arg2 = (bool)(SWIG_As_bool(obj1));
20483 if (SWIG_arg_fail(2)) SWIG_fail;
20484 }
20485 }
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj;
20502 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20503 bool arg2 ;
20504 PyObject * obj0 = 0 ;
20505 PyObject * obj1 = 0 ;
20506 char *kwnames[] = {
20507 (char *) "self",(char *) "show", NULL
20508 };
20509
20510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20512 if (SWIG_arg_fail(1)) SWIG_fail;
20513 {
20514 arg2 = (bool)(SWIG_As_bool(obj1));
20515 if (SWIG_arg_fail(2)) SWIG_fail;
20516 }
20517 {
20518 PyThreadState* __tstate = wxPyBeginAllowThreads();
20519 (arg1)->SetShow(arg2);
20520
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 Py_INCREF(Py_None); resultobj = Py_None;
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj;
20533 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20534 bool result;
20535 PyObject * obj0 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "self", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(1)) SWIG_fail;
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20546
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 {
20551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20552 }
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20560 PyObject *obj;
20561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20562 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20563 Py_INCREF(obj);
20564 return Py_BuildValue((char *)"");
20565 }
20566 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20567 PyObject *resultobj;
20568 int arg1 = (int) 0 ;
20569 bool arg2 = (bool) true ;
20570 wxIconizeEvent *result;
20571 PyObject * obj0 = 0 ;
20572 PyObject * obj1 = 0 ;
20573 char *kwnames[] = {
20574 (char *) "id",(char *) "iconized", NULL
20575 };
20576
20577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20578 if (obj0) {
20579 {
20580 arg1 = (int)(SWIG_As_int(obj0));
20581 if (SWIG_arg_fail(1)) SWIG_fail;
20582 }
20583 }
20584 if (obj1) {
20585 {
20586 arg2 = (bool)(SWIG_As_bool(obj1));
20587 if (SWIG_arg_fail(2)) SWIG_fail;
20588 }
20589 }
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20593
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj;
20606 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20607 bool result;
20608 PyObject * obj0 = 0 ;
20609 char *kwnames[] = {
20610 (char *) "self", NULL
20611 };
20612
20613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20615 if (SWIG_arg_fail(1)) SWIG_fail;
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (bool)(arg1)->Iconized();
20619
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 {
20624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20633 PyObject *obj;
20634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20635 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20636 Py_INCREF(obj);
20637 return Py_BuildValue((char *)"");
20638 }
20639 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj;
20641 int arg1 = (int) 0 ;
20642 wxMaximizeEvent *result;
20643 PyObject * obj0 = 0 ;
20644 char *kwnames[] = {
20645 (char *) "id", NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20649 if (obj0) {
20650 {
20651 arg1 = (int)(SWIG_As_int(obj0));
20652 if (SWIG_arg_fail(1)) SWIG_fail;
20653 }
20654 }
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20658
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20670 PyObject *obj;
20671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20672 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20673 Py_INCREF(obj);
20674 return Py_BuildValue((char *)"");
20675 }
20676 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20677 PyObject *resultobj;
20678 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20679 wxPoint result;
20680 PyObject * obj0 = 0 ;
20681 char *kwnames[] = {
20682 (char *) "self", NULL
20683 };
20684
20685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20687 if (SWIG_arg_fail(1)) SWIG_fail;
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (arg1)->GetPosition();
20691
20692 wxPyEndAllowThreads(__tstate);
20693 if (PyErr_Occurred()) SWIG_fail;
20694 }
20695 {
20696 wxPoint * resultptr;
20697 resultptr = new wxPoint((wxPoint &)(result));
20698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20699 }
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20707 PyObject *resultobj;
20708 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20709 int result;
20710 PyObject * obj0 = 0 ;
20711 char *kwnames[] = {
20712 (char *) "self", NULL
20713 };
20714
20715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20717 if (SWIG_arg_fail(1)) SWIG_fail;
20718 {
20719 PyThreadState* __tstate = wxPyBeginAllowThreads();
20720 result = (int)(arg1)->GetNumberOfFiles();
20721
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 {
20726 resultobj = SWIG_From_int((int)(result));
20727 }
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj;
20736 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20737 PyObject *result;
20738 PyObject * obj0 = 0 ;
20739 char *kwnames[] = {
20740 (char *) "self", NULL
20741 };
20742
20743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20745 if (SWIG_arg_fail(1)) SWIG_fail;
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20749
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 resultobj = result;
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20761 PyObject *obj;
20762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20763 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20764 Py_INCREF(obj);
20765 return Py_BuildValue((char *)"");
20766 }
20767 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj;
20769 int arg1 = (int) 0 ;
20770 wxUpdateUIEvent *result;
20771 PyObject * obj0 = 0 ;
20772 char *kwnames[] = {
20773 (char *) "commandId", NULL
20774 };
20775
20776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20777 if (obj0) {
20778 {
20779 arg1 = (int)(SWIG_As_int(obj0));
20780 if (SWIG_arg_fail(1)) SWIG_fail;
20781 }
20782 }
20783 {
20784 PyThreadState* __tstate = wxPyBeginAllowThreads();
20785 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20786
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20791 return resultobj;
20792 fail:
20793 return NULL;
20794 }
20795
20796
20797 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20798 PyObject *resultobj;
20799 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20800 bool result;
20801 PyObject * obj0 = 0 ;
20802 char *kwnames[] = {
20803 (char *) "self", NULL
20804 };
20805
20806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20808 if (SWIG_arg_fail(1)) SWIG_fail;
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20812
20813 wxPyEndAllowThreads(__tstate);
20814 if (PyErr_Occurred()) SWIG_fail;
20815 }
20816 {
20817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20818 }
20819 return resultobj;
20820 fail:
20821 return NULL;
20822 }
20823
20824
20825 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20826 PyObject *resultobj;
20827 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20828 bool result;
20829 PyObject * obj0 = 0 ;
20830 char *kwnames[] = {
20831 (char *) "self", NULL
20832 };
20833
20834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20836 if (SWIG_arg_fail(1)) SWIG_fail;
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20840
20841 wxPyEndAllowThreads(__tstate);
20842 if (PyErr_Occurred()) SWIG_fail;
20843 }
20844 {
20845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20846 }
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20854 PyObject *resultobj;
20855 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20856 wxString result;
20857 PyObject * obj0 = 0 ;
20858 char *kwnames[] = {
20859 (char *) "self", NULL
20860 };
20861
20862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20864 if (SWIG_arg_fail(1)) SWIG_fail;
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20868
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 {
20873 #if wxUSE_UNICODE
20874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20875 #else
20876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20877 #endif
20878 }
20879 return resultobj;
20880 fail:
20881 return NULL;
20882 }
20883
20884
20885 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20886 PyObject *resultobj;
20887 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20888 bool result;
20889 PyObject * obj0 = 0 ;
20890 char *kwnames[] = {
20891 (char *) "self", NULL
20892 };
20893
20894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20896 if (SWIG_arg_fail(1)) SWIG_fail;
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20900
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 {
20905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20906 }
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20914 PyObject *resultobj;
20915 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20916 bool result;
20917 PyObject * obj0 = 0 ;
20918 char *kwnames[] = {
20919 (char *) "self", NULL
20920 };
20921
20922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20924 if (SWIG_arg_fail(1)) SWIG_fail;
20925 {
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20928
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 {
20933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20934 }
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20942 PyObject *resultobj;
20943 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20944 bool result;
20945 PyObject * obj0 = 0 ;
20946 char *kwnames[] = {
20947 (char *) "self", NULL
20948 };
20949
20950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20952 if (SWIG_arg_fail(1)) SWIG_fail;
20953 {
20954 PyThreadState* __tstate = wxPyBeginAllowThreads();
20955 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20956
20957 wxPyEndAllowThreads(__tstate);
20958 if (PyErr_Occurred()) SWIG_fail;
20959 }
20960 {
20961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20962 }
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj;
20971 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20972 bool arg2 ;
20973 PyObject * obj0 = 0 ;
20974 PyObject * obj1 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self",(char *) "check", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 arg2 = (bool)(SWIG_As_bool(obj1));
20984 if (SWIG_arg_fail(2)) SWIG_fail;
20985 }
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 (arg1)->Check(arg2);
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 Py_INCREF(Py_None); resultobj = Py_None;
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj;
21002 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21003 bool arg2 ;
21004 PyObject * obj0 = 0 ;
21005 PyObject * obj1 = 0 ;
21006 char *kwnames[] = {
21007 (char *) "self",(char *) "enable", NULL
21008 };
21009
21010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21012 if (SWIG_arg_fail(1)) SWIG_fail;
21013 {
21014 arg2 = (bool)(SWIG_As_bool(obj1));
21015 if (SWIG_arg_fail(2)) SWIG_fail;
21016 }
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 (arg1)->Enable(arg2);
21020
21021 wxPyEndAllowThreads(__tstate);
21022 if (PyErr_Occurred()) SWIG_fail;
21023 }
21024 Py_INCREF(Py_None); resultobj = Py_None;
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21032 PyObject *resultobj;
21033 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21034 wxString *arg2 = 0 ;
21035 bool temp2 = false ;
21036 PyObject * obj0 = 0 ;
21037 PyObject * obj1 = 0 ;
21038 char *kwnames[] = {
21039 (char *) "self",(char *) "text", NULL
21040 };
21041
21042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21044 if (SWIG_arg_fail(1)) SWIG_fail;
21045 {
21046 arg2 = wxString_in_helper(obj1);
21047 if (arg2 == NULL) SWIG_fail;
21048 temp2 = true;
21049 }
21050 {
21051 PyThreadState* __tstate = wxPyBeginAllowThreads();
21052 (arg1)->SetText((wxString const &)*arg2);
21053
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 Py_INCREF(Py_None); resultobj = Py_None;
21058 {
21059 if (temp2)
21060 delete arg2;
21061 }
21062 return resultobj;
21063 fail:
21064 {
21065 if (temp2)
21066 delete arg2;
21067 }
21068 return NULL;
21069 }
21070
21071
21072 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21073 PyObject *resultobj;
21074 long arg1 ;
21075 PyObject * obj0 = 0 ;
21076 char *kwnames[] = {
21077 (char *) "updateInterval", NULL
21078 };
21079
21080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21081 {
21082 arg1 = (long)(SWIG_As_long(obj0));
21083 if (SWIG_arg_fail(1)) SWIG_fail;
21084 }
21085 {
21086 PyThreadState* __tstate = wxPyBeginAllowThreads();
21087 wxUpdateUIEvent::SetUpdateInterval(arg1);
21088
21089 wxPyEndAllowThreads(__tstate);
21090 if (PyErr_Occurred()) SWIG_fail;
21091 }
21092 Py_INCREF(Py_None); resultobj = Py_None;
21093 return resultobj;
21094 fail:
21095 return NULL;
21096 }
21097
21098
21099 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21100 PyObject *resultobj;
21101 long result;
21102 char *kwnames[] = {
21103 NULL
21104 };
21105
21106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21107 {
21108 PyThreadState* __tstate = wxPyBeginAllowThreads();
21109 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21110
21111 wxPyEndAllowThreads(__tstate);
21112 if (PyErr_Occurred()) SWIG_fail;
21113 }
21114 {
21115 resultobj = SWIG_From_long((long)(result));
21116 }
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21124 PyObject *resultobj;
21125 wxWindow *arg1 = (wxWindow *) 0 ;
21126 bool result;
21127 PyObject * obj0 = 0 ;
21128 char *kwnames[] = {
21129 (char *) "win", NULL
21130 };
21131
21132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21134 if (SWIG_arg_fail(1)) SWIG_fail;
21135 {
21136 PyThreadState* __tstate = wxPyBeginAllowThreads();
21137 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21138
21139 wxPyEndAllowThreads(__tstate);
21140 if (PyErr_Occurred()) SWIG_fail;
21141 }
21142 {
21143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21144 }
21145 return resultobj;
21146 fail:
21147 return NULL;
21148 }
21149
21150
21151 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21152 PyObject *resultobj;
21153 char *kwnames[] = {
21154 NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21158 {
21159 PyThreadState* __tstate = wxPyBeginAllowThreads();
21160 wxUpdateUIEvent::ResetUpdateTime();
21161
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 Py_INCREF(Py_None); resultobj = Py_None;
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj;
21174 wxUpdateUIMode arg1 ;
21175 PyObject * obj0 = 0 ;
21176 char *kwnames[] = {
21177 (char *) "mode", NULL
21178 };
21179
21180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21181 {
21182 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21183 if (SWIG_arg_fail(1)) SWIG_fail;
21184 }
21185 {
21186 PyThreadState* __tstate = wxPyBeginAllowThreads();
21187 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21188
21189 wxPyEndAllowThreads(__tstate);
21190 if (PyErr_Occurred()) SWIG_fail;
21191 }
21192 Py_INCREF(Py_None); resultobj = Py_None;
21193 return resultobj;
21194 fail:
21195 return NULL;
21196 }
21197
21198
21199 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21200 PyObject *resultobj;
21201 wxUpdateUIMode result;
21202 char *kwnames[] = {
21203 NULL
21204 };
21205
21206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21210
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 resultobj = SWIG_From_int((result));
21215 return resultobj;
21216 fail:
21217 return NULL;
21218 }
21219
21220
21221 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21222 PyObject *obj;
21223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21224 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21225 Py_INCREF(obj);
21226 return Py_BuildValue((char *)"");
21227 }
21228 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj;
21230 wxSysColourChangedEvent *result;
21231 char *kwnames[] = {
21232 NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21236 {
21237 PyThreadState* __tstate = wxPyBeginAllowThreads();
21238 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21239
21240 wxPyEndAllowThreads(__tstate);
21241 if (PyErr_Occurred()) SWIG_fail;
21242 }
21243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21251 PyObject *obj;
21252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21253 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21254 Py_INCREF(obj);
21255 return Py_BuildValue((char *)"");
21256 }
21257 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21258 PyObject *resultobj;
21259 int arg1 = (int) 0 ;
21260 wxWindow *arg2 = (wxWindow *) NULL ;
21261 wxMouseCaptureChangedEvent *result;
21262 PyObject * obj0 = 0 ;
21263 PyObject * obj1 = 0 ;
21264 char *kwnames[] = {
21265 (char *) "winid",(char *) "gainedCapture", NULL
21266 };
21267
21268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21269 if (obj0) {
21270 {
21271 arg1 = (int)(SWIG_As_int(obj0));
21272 if (SWIG_arg_fail(1)) SWIG_fail;
21273 }
21274 }
21275 if (obj1) {
21276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21277 if (SWIG_arg_fail(2)) SWIG_fail;
21278 }
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21282
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj;
21295 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21296 wxWindow *result;
21297 PyObject * obj0 = 0 ;
21298 char *kwnames[] = {
21299 (char *) "self", NULL
21300 };
21301
21302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21304 if (SWIG_arg_fail(1)) SWIG_fail;
21305 {
21306 PyThreadState* __tstate = wxPyBeginAllowThreads();
21307 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21308
21309 wxPyEndAllowThreads(__tstate);
21310 if (PyErr_Occurred()) SWIG_fail;
21311 }
21312 {
21313 resultobj = wxPyMake_wxObject(result, 0);
21314 }
21315 return resultobj;
21316 fail:
21317 return NULL;
21318 }
21319
21320
21321 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21322 PyObject *obj;
21323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21324 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21325 Py_INCREF(obj);
21326 return Py_BuildValue((char *)"");
21327 }
21328 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21329 PyObject *resultobj;
21330 wxDisplayChangedEvent *result;
21331 char *kwnames[] = {
21332 NULL
21333 };
21334
21335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21351 PyObject *obj;
21352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21353 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21354 Py_INCREF(obj);
21355 return Py_BuildValue((char *)"");
21356 }
21357 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 int arg1 = (int) 0 ;
21360 wxPaletteChangedEvent *result;
21361 PyObject * obj0 = 0 ;
21362 char *kwnames[] = {
21363 (char *) "id", NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21367 if (obj0) {
21368 {
21369 arg1 = (int)(SWIG_As_int(obj0));
21370 if (SWIG_arg_fail(1)) SWIG_fail;
21371 }
21372 }
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21376
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21381 return resultobj;
21382 fail:
21383 return NULL;
21384 }
21385
21386
21387 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21388 PyObject *resultobj;
21389 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21390 wxWindow *arg2 = (wxWindow *) 0 ;
21391 PyObject * obj0 = 0 ;
21392 PyObject * obj1 = 0 ;
21393 char *kwnames[] = {
21394 (char *) "self",(char *) "win", NULL
21395 };
21396
21397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21399 if (SWIG_arg_fail(1)) SWIG_fail;
21400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21401 if (SWIG_arg_fail(2)) SWIG_fail;
21402 {
21403 PyThreadState* __tstate = wxPyBeginAllowThreads();
21404 (arg1)->SetChangedWindow(arg2);
21405
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 Py_INCREF(Py_None); resultobj = Py_None;
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21417 PyObject *resultobj;
21418 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21419 wxWindow *result;
21420 PyObject * obj0 = 0 ;
21421 char *kwnames[] = {
21422 (char *) "self", NULL
21423 };
21424
21425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21427 if (SWIG_arg_fail(1)) SWIG_fail;
21428 {
21429 PyThreadState* __tstate = wxPyBeginAllowThreads();
21430 result = (wxWindow *)(arg1)->GetChangedWindow();
21431
21432 wxPyEndAllowThreads(__tstate);
21433 if (PyErr_Occurred()) SWIG_fail;
21434 }
21435 {
21436 resultobj = wxPyMake_wxObject(result, 0);
21437 }
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21445 PyObject *obj;
21446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21447 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21448 Py_INCREF(obj);
21449 return Py_BuildValue((char *)"");
21450 }
21451 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21452 PyObject *resultobj;
21453 int arg1 = (int) 0 ;
21454 wxQueryNewPaletteEvent *result;
21455 PyObject * obj0 = 0 ;
21456 char *kwnames[] = {
21457 (char *) "winid", NULL
21458 };
21459
21460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21461 if (obj0) {
21462 {
21463 arg1 = (int)(SWIG_As_int(obj0));
21464 if (SWIG_arg_fail(1)) SWIG_fail;
21465 }
21466 }
21467 {
21468 PyThreadState* __tstate = wxPyBeginAllowThreads();
21469 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21470
21471 wxPyEndAllowThreads(__tstate);
21472 if (PyErr_Occurred()) SWIG_fail;
21473 }
21474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21475 return resultobj;
21476 fail:
21477 return NULL;
21478 }
21479
21480
21481 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21482 PyObject *resultobj;
21483 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21484 bool arg2 ;
21485 PyObject * obj0 = 0 ;
21486 PyObject * obj1 = 0 ;
21487 char *kwnames[] = {
21488 (char *) "self",(char *) "realized", NULL
21489 };
21490
21491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21493 if (SWIG_arg_fail(1)) SWIG_fail;
21494 {
21495 arg2 = (bool)(SWIG_As_bool(obj1));
21496 if (SWIG_arg_fail(2)) SWIG_fail;
21497 }
21498 {
21499 PyThreadState* __tstate = wxPyBeginAllowThreads();
21500 (arg1)->SetPaletteRealized(arg2);
21501
21502 wxPyEndAllowThreads(__tstate);
21503 if (PyErr_Occurred()) SWIG_fail;
21504 }
21505 Py_INCREF(Py_None); resultobj = Py_None;
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21513 PyObject *resultobj;
21514 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21515 bool result;
21516 PyObject * obj0 = 0 ;
21517 char *kwnames[] = {
21518 (char *) "self", NULL
21519 };
21520
21521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21523 if (SWIG_arg_fail(1)) SWIG_fail;
21524 {
21525 PyThreadState* __tstate = wxPyBeginAllowThreads();
21526 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21527
21528 wxPyEndAllowThreads(__tstate);
21529 if (PyErr_Occurred()) SWIG_fail;
21530 }
21531 {
21532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21533 }
21534 return resultobj;
21535 fail:
21536 return NULL;
21537 }
21538
21539
21540 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21541 PyObject *obj;
21542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21543 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21544 Py_INCREF(obj);
21545 return Py_BuildValue((char *)"");
21546 }
21547 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj;
21549 wxNavigationKeyEvent *result;
21550 char *kwnames[] = {
21551 NULL
21552 };
21553
21554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21555 {
21556 PyThreadState* __tstate = wxPyBeginAllowThreads();
21557 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21558
21559 wxPyEndAllowThreads(__tstate);
21560 if (PyErr_Occurred()) SWIG_fail;
21561 }
21562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21563 return resultobj;
21564 fail:
21565 return NULL;
21566 }
21567
21568
21569 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21570 PyObject *resultobj;
21571 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21572 bool result;
21573 PyObject * obj0 = 0 ;
21574 char *kwnames[] = {
21575 (char *) "self", NULL
21576 };
21577
21578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21580 if (SWIG_arg_fail(1)) SWIG_fail;
21581 {
21582 PyThreadState* __tstate = wxPyBeginAllowThreads();
21583 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21584
21585 wxPyEndAllowThreads(__tstate);
21586 if (PyErr_Occurred()) SWIG_fail;
21587 }
21588 {
21589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21590 }
21591 return resultobj;
21592 fail:
21593 return NULL;
21594 }
21595
21596
21597 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21598 PyObject *resultobj;
21599 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21600 bool arg2 ;
21601 PyObject * obj0 = 0 ;
21602 PyObject * obj1 = 0 ;
21603 char *kwnames[] = {
21604 (char *) "self",(char *) "forward", NULL
21605 };
21606
21607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21609 if (SWIG_arg_fail(1)) SWIG_fail;
21610 {
21611 arg2 = (bool)(SWIG_As_bool(obj1));
21612 if (SWIG_arg_fail(2)) SWIG_fail;
21613 }
21614 {
21615 PyThreadState* __tstate = wxPyBeginAllowThreads();
21616 (arg1)->SetDirection(arg2);
21617
21618 wxPyEndAllowThreads(__tstate);
21619 if (PyErr_Occurred()) SWIG_fail;
21620 }
21621 Py_INCREF(Py_None); resultobj = Py_None;
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21629 PyObject *resultobj;
21630 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21631 bool result;
21632 PyObject * obj0 = 0 ;
21633 char *kwnames[] = {
21634 (char *) "self", NULL
21635 };
21636
21637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21639 if (SWIG_arg_fail(1)) SWIG_fail;
21640 {
21641 PyThreadState* __tstate = wxPyBeginAllowThreads();
21642 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21643
21644 wxPyEndAllowThreads(__tstate);
21645 if (PyErr_Occurred()) SWIG_fail;
21646 }
21647 {
21648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21649 }
21650 return resultobj;
21651 fail:
21652 return NULL;
21653 }
21654
21655
21656 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21657 PyObject *resultobj;
21658 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21659 bool arg2 ;
21660 PyObject * obj0 = 0 ;
21661 PyObject * obj1 = 0 ;
21662 char *kwnames[] = {
21663 (char *) "self",(char *) "ischange", NULL
21664 };
21665
21666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21668 if (SWIG_arg_fail(1)) SWIG_fail;
21669 {
21670 arg2 = (bool)(SWIG_As_bool(obj1));
21671 if (SWIG_arg_fail(2)) SWIG_fail;
21672 }
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 (arg1)->SetWindowChange(arg2);
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 Py_INCREF(Py_None); resultobj = Py_None;
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21688 PyObject *resultobj;
21689 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21690 bool result;
21691 PyObject * obj0 = 0 ;
21692 char *kwnames[] = {
21693 (char *) "self", NULL
21694 };
21695
21696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21698 if (SWIG_arg_fail(1)) SWIG_fail;
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21702
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 {
21707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21708 }
21709 return resultobj;
21710 fail:
21711 return NULL;
21712 }
21713
21714
21715 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21716 PyObject *resultobj;
21717 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21718 bool arg2 ;
21719 PyObject * obj0 = 0 ;
21720 PyObject * obj1 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self",(char *) "bIs", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 arg2 = (bool)(SWIG_As_bool(obj1));
21730 if (SWIG_arg_fail(2)) SWIG_fail;
21731 }
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 (arg1)->SetFromTab(arg2);
21735
21736 wxPyEndAllowThreads(__tstate);
21737 if (PyErr_Occurred()) SWIG_fail;
21738 }
21739 Py_INCREF(Py_None); resultobj = Py_None;
21740 return resultobj;
21741 fail:
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21749 long arg2 ;
21750 PyObject * obj0 = 0 ;
21751 PyObject * obj1 = 0 ;
21752 char *kwnames[] = {
21753 (char *) "self",(char *) "flags", NULL
21754 };
21755
21756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21758 if (SWIG_arg_fail(1)) SWIG_fail;
21759 {
21760 arg2 = (long)(SWIG_As_long(obj1));
21761 if (SWIG_arg_fail(2)) SWIG_fail;
21762 }
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 (arg1)->SetFlags(arg2);
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 Py_INCREF(Py_None); resultobj = Py_None;
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21780 wxWindow *result;
21781 PyObject * obj0 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "self", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21788 if (SWIG_arg_fail(1)) SWIG_fail;
21789 {
21790 PyThreadState* __tstate = wxPyBeginAllowThreads();
21791 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21792
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 {
21797 resultobj = wxPyMake_wxObject(result, 0);
21798 }
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21806 PyObject *resultobj;
21807 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21808 wxWindow *arg2 = (wxWindow *) 0 ;
21809 PyObject * obj0 = 0 ;
21810 PyObject * obj1 = 0 ;
21811 char *kwnames[] = {
21812 (char *) "self",(char *) "win", NULL
21813 };
21814
21815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(1)) SWIG_fail;
21818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21819 if (SWIG_arg_fail(2)) SWIG_fail;
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 (arg1)->SetCurrentFocus(arg2);
21823
21824 wxPyEndAllowThreads(__tstate);
21825 if (PyErr_Occurred()) SWIG_fail;
21826 }
21827 Py_INCREF(Py_None); resultobj = Py_None;
21828 return resultobj;
21829 fail:
21830 return NULL;
21831 }
21832
21833
21834 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21835 PyObject *obj;
21836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21837 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21838 Py_INCREF(obj);
21839 return Py_BuildValue((char *)"");
21840 }
21841 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21842 PyObject *resultobj;
21843 wxWindow *arg1 = (wxWindow *) NULL ;
21844 wxWindowCreateEvent *result;
21845 PyObject * obj0 = 0 ;
21846 char *kwnames[] = {
21847 (char *) "win", NULL
21848 };
21849
21850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21851 if (obj0) {
21852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21853 if (SWIG_arg_fail(1)) SWIG_fail;
21854 }
21855 {
21856 PyThreadState* __tstate = wxPyBeginAllowThreads();
21857 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21858
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21863 return resultobj;
21864 fail:
21865 return NULL;
21866 }
21867
21868
21869 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21870 PyObject *resultobj;
21871 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21872 wxWindow *result;
21873 PyObject * obj0 = 0 ;
21874 char *kwnames[] = {
21875 (char *) "self", NULL
21876 };
21877
21878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21880 if (SWIG_arg_fail(1)) SWIG_fail;
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21884
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889 resultobj = wxPyMake_wxObject(result, 0);
21890 }
21891 return resultobj;
21892 fail:
21893 return NULL;
21894 }
21895
21896
21897 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21898 PyObject *obj;
21899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21900 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21901 Py_INCREF(obj);
21902 return Py_BuildValue((char *)"");
21903 }
21904 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj;
21906 wxWindow *arg1 = (wxWindow *) NULL ;
21907 wxWindowDestroyEvent *result;
21908 PyObject * obj0 = 0 ;
21909 char *kwnames[] = {
21910 (char *) "win", NULL
21911 };
21912
21913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21914 if (obj0) {
21915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21916 if (SWIG_arg_fail(1)) SWIG_fail;
21917 }
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21921
21922 wxPyEndAllowThreads(__tstate);
21923 if (PyErr_Occurred()) SWIG_fail;
21924 }
21925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21933 PyObject *resultobj;
21934 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21935 wxWindow *result;
21936 PyObject * obj0 = 0 ;
21937 char *kwnames[] = {
21938 (char *) "self", NULL
21939 };
21940
21941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21943 if (SWIG_arg_fail(1)) SWIG_fail;
21944 {
21945 PyThreadState* __tstate = wxPyBeginAllowThreads();
21946 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21947
21948 wxPyEndAllowThreads(__tstate);
21949 if (PyErr_Occurred()) SWIG_fail;
21950 }
21951 {
21952 resultobj = wxPyMake_wxObject(result, 0);
21953 }
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21961 PyObject *obj;
21962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21963 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21964 Py_INCREF(obj);
21965 return Py_BuildValue((char *)"");
21966 }
21967 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj;
21969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21970 int arg2 = (int) 0 ;
21971 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21972 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21973 wxContextMenuEvent *result;
21974 wxPoint temp3 ;
21975 PyObject * obj0 = 0 ;
21976 PyObject * obj1 = 0 ;
21977 PyObject * obj2 = 0 ;
21978 char *kwnames[] = {
21979 (char *) "type",(char *) "winid",(char *) "pt", NULL
21980 };
21981
21982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21983 if (obj0) {
21984 {
21985 arg1 = (wxEventType)(SWIG_As_int(obj0));
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 }
21988 }
21989 if (obj1) {
21990 {
21991 arg2 = (int)(SWIG_As_int(obj1));
21992 if (SWIG_arg_fail(2)) SWIG_fail;
21993 }
21994 }
21995 if (obj2) {
21996 {
21997 arg3 = &temp3;
21998 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21999 }
22000 }
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj;
22017 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22018 wxPoint *result;
22019 PyObject * obj0 = 0 ;
22020 char *kwnames[] = {
22021 (char *) "self", NULL
22022 };
22023
22024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22026 if (SWIG_arg_fail(1)) SWIG_fail;
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 {
22030 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22031 result = (wxPoint *) &_result_ref;
22032 }
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj;
22046 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22047 wxPoint *arg2 = 0 ;
22048 wxPoint temp2 ;
22049 PyObject * obj0 = 0 ;
22050 PyObject * obj1 = 0 ;
22051 char *kwnames[] = {
22052 (char *) "self",(char *) "pos", NULL
22053 };
22054
22055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22057 if (SWIG_arg_fail(1)) SWIG_fail;
22058 {
22059 arg2 = &temp2;
22060 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22061 }
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 (arg1)->SetPosition((wxPoint const &)*arg2);
22065
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 Py_INCREF(Py_None); resultobj = Py_None;
22070 return resultobj;
22071 fail:
22072 return NULL;
22073 }
22074
22075
22076 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22077 PyObject *obj;
22078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22079 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22080 Py_INCREF(obj);
22081 return Py_BuildValue((char *)"");
22082 }
22083 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj;
22085 wxIdleEvent *result;
22086 char *kwnames[] = {
22087 NULL
22088 };
22089
22090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 result = (wxIdleEvent *)new wxIdleEvent();
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22106 PyObject *resultobj;
22107 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22108 bool arg2 = (bool) true ;
22109 PyObject * obj0 = 0 ;
22110 PyObject * obj1 = 0 ;
22111 char *kwnames[] = {
22112 (char *) "self",(char *) "needMore", NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(1)) SWIG_fail;
22118 if (obj1) {
22119 {
22120 arg2 = (bool)(SWIG_As_bool(obj1));
22121 if (SWIG_arg_fail(2)) SWIG_fail;
22122 }
22123 }
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 (arg1)->RequestMore(arg2);
22127
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 Py_INCREF(Py_None); resultobj = Py_None;
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj;
22140 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22141 bool result;
22142 PyObject * obj0 = 0 ;
22143 char *kwnames[] = {
22144 (char *) "self", NULL
22145 };
22146
22147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22149 if (SWIG_arg_fail(1)) SWIG_fail;
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22153
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 {
22158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22159 }
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22167 PyObject *resultobj;
22168 wxIdleMode arg1 ;
22169 PyObject * obj0 = 0 ;
22170 char *kwnames[] = {
22171 (char *) "mode", NULL
22172 };
22173
22174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22175 {
22176 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22177 if (SWIG_arg_fail(1)) SWIG_fail;
22178 }
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 wxIdleEvent::SetMode((wxIdleMode )arg1);
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 Py_INCREF(Py_None); resultobj = Py_None;
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj;
22195 wxIdleMode result;
22196 char *kwnames[] = {
22197 NULL
22198 };
22199
22200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22201 {
22202 PyThreadState* __tstate = wxPyBeginAllowThreads();
22203 result = (wxIdleMode)wxIdleEvent::GetMode();
22204
22205 wxPyEndAllowThreads(__tstate);
22206 if (PyErr_Occurred()) SWIG_fail;
22207 }
22208 resultobj = SWIG_From_int((result));
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj;
22217 wxWindow *arg1 = (wxWindow *) 0 ;
22218 bool result;
22219 PyObject * obj0 = 0 ;
22220 char *kwnames[] = {
22221 (char *) "win", NULL
22222 };
22223
22224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22226 if (SWIG_arg_fail(1)) SWIG_fail;
22227 {
22228 PyThreadState* __tstate = wxPyBeginAllowThreads();
22229 result = (bool)wxIdleEvent::CanSend(arg1);
22230
22231 wxPyEndAllowThreads(__tstate);
22232 if (PyErr_Occurred()) SWIG_fail;
22233 }
22234 {
22235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22236 }
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22244 PyObject *obj;
22245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22246 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22247 Py_INCREF(obj);
22248 return Py_BuildValue((char *)"");
22249 }
22250 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22251 PyObject *resultobj;
22252 int arg1 = (int) 0 ;
22253 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22254 wxPyEvent *result;
22255 PyObject * obj0 = 0 ;
22256 PyObject * obj1 = 0 ;
22257 char *kwnames[] = {
22258 (char *) "winid",(char *) "commandType", NULL
22259 };
22260
22261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22262 if (obj0) {
22263 {
22264 arg1 = (int)(SWIG_As_int(obj0));
22265 if (SWIG_arg_fail(1)) SWIG_fail;
22266 }
22267 }
22268 if (obj1) {
22269 {
22270 arg2 = (wxEventType)(SWIG_As_int(obj1));
22271 if (SWIG_arg_fail(2)) SWIG_fail;
22272 }
22273 }
22274 {
22275 PyThreadState* __tstate = wxPyBeginAllowThreads();
22276 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22277
22278 wxPyEndAllowThreads(__tstate);
22279 if (PyErr_Occurred()) SWIG_fail;
22280 }
22281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22282 return resultobj;
22283 fail:
22284 return NULL;
22285 }
22286
22287
22288 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22289 PyObject *resultobj;
22290 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22291 PyObject * obj0 = 0 ;
22292 char *kwnames[] = {
22293 (char *) "self", NULL
22294 };
22295
22296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22298 if (SWIG_arg_fail(1)) SWIG_fail;
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 delete arg1;
22302
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 Py_INCREF(Py_None); resultobj = Py_None;
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj;
22315 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22316 PyObject *arg2 = (PyObject *) 0 ;
22317 PyObject * obj0 = 0 ;
22318 PyObject * obj1 = 0 ;
22319 char *kwnames[] = {
22320 (char *) "self",(char *) "self", NULL
22321 };
22322
22323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22325 if (SWIG_arg_fail(1)) SWIG_fail;
22326 arg2 = obj1;
22327 {
22328 PyThreadState* __tstate = wxPyBeginAllowThreads();
22329 (arg1)->SetSelf(arg2);
22330
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 Py_INCREF(Py_None); resultobj = Py_None;
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22342 PyObject *resultobj;
22343 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22344 PyObject *result;
22345 PyObject * obj0 = 0 ;
22346 char *kwnames[] = {
22347 (char *) "self", NULL
22348 };
22349
22350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22352 if (SWIG_arg_fail(1)) SWIG_fail;
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 result = (PyObject *)(arg1)->GetSelf();
22356
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 resultobj = result;
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22368 PyObject *obj;
22369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22370 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22371 Py_INCREF(obj);
22372 return Py_BuildValue((char *)"");
22373 }
22374 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22375 PyObject *resultobj;
22376 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22377 int arg2 = (int) 0 ;
22378 wxPyCommandEvent *result;
22379 PyObject * obj0 = 0 ;
22380 PyObject * obj1 = 0 ;
22381 char *kwnames[] = {
22382 (char *) "commandType",(char *) "id", NULL
22383 };
22384
22385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22386 if (obj0) {
22387 {
22388 arg1 = (wxEventType)(SWIG_As_int(obj0));
22389 if (SWIG_arg_fail(1)) SWIG_fail;
22390 }
22391 }
22392 if (obj1) {
22393 {
22394 arg2 = (int)(SWIG_As_int(obj1));
22395 if (SWIG_arg_fail(2)) SWIG_fail;
22396 }
22397 }
22398 {
22399 PyThreadState* __tstate = wxPyBeginAllowThreads();
22400 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22401
22402 wxPyEndAllowThreads(__tstate);
22403 if (PyErr_Occurred()) SWIG_fail;
22404 }
22405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22413 PyObject *resultobj;
22414 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22415 PyObject * obj0 = 0 ;
22416 char *kwnames[] = {
22417 (char *) "self", NULL
22418 };
22419
22420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22422 if (SWIG_arg_fail(1)) SWIG_fail;
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 delete arg1;
22426
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 Py_INCREF(Py_None); resultobj = Py_None;
22431 return resultobj;
22432 fail:
22433 return NULL;
22434 }
22435
22436
22437 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22438 PyObject *resultobj;
22439 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22440 PyObject *arg2 = (PyObject *) 0 ;
22441 PyObject * obj0 = 0 ;
22442 PyObject * obj1 = 0 ;
22443 char *kwnames[] = {
22444 (char *) "self",(char *) "self", NULL
22445 };
22446
22447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22449 if (SWIG_arg_fail(1)) SWIG_fail;
22450 arg2 = obj1;
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 (arg1)->SetSelf(arg2);
22454
22455 wxPyEndAllowThreads(__tstate);
22456 if (PyErr_Occurred()) SWIG_fail;
22457 }
22458 Py_INCREF(Py_None); resultobj = Py_None;
22459 return resultobj;
22460 fail:
22461 return NULL;
22462 }
22463
22464
22465 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22466 PyObject *resultobj;
22467 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22468 PyObject *result;
22469 PyObject * obj0 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 result = (PyObject *)(arg1)->GetSelf();
22480
22481 wxPyEndAllowThreads(__tstate);
22482 if (PyErr_Occurred()) SWIG_fail;
22483 }
22484 resultobj = result;
22485 return resultobj;
22486 fail:
22487 return NULL;
22488 }
22489
22490
22491 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22492 PyObject *obj;
22493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22494 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22495 Py_INCREF(obj);
22496 return Py_BuildValue((char *)"");
22497 }
22498 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22499 PyObject *resultobj;
22500 wxWindow *arg1 = (wxWindow *) 0 ;
22501 wxDateTime *arg2 = 0 ;
22502 wxEventType arg3 ;
22503 wxDateEvent *result;
22504 PyObject * obj0 = 0 ;
22505 PyObject * obj1 = 0 ;
22506 PyObject * obj2 = 0 ;
22507 char *kwnames[] = {
22508 (char *) "win",(char *) "dt",(char *) "type", NULL
22509 };
22510
22511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22513 if (SWIG_arg_fail(1)) SWIG_fail;
22514 {
22515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22516 if (SWIG_arg_fail(2)) SWIG_fail;
22517 if (arg2 == NULL) {
22518 SWIG_null_ref("wxDateTime");
22519 }
22520 if (SWIG_arg_fail(2)) SWIG_fail;
22521 }
22522 {
22523 arg3 = (wxEventType)(SWIG_As_int(obj2));
22524 if (SWIG_arg_fail(3)) SWIG_fail;
22525 }
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22529
22530 wxPyEndAllowThreads(__tstate);
22531 if (PyErr_Occurred()) SWIG_fail;
22532 }
22533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22541 PyObject *resultobj;
22542 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22543 wxDateTime *result;
22544 PyObject * obj0 = 0 ;
22545 char *kwnames[] = {
22546 (char *) "self", NULL
22547 };
22548
22549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22551 if (SWIG_arg_fail(1)) SWIG_fail;
22552 {
22553 PyThreadState* __tstate = wxPyBeginAllowThreads();
22554 {
22555 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22556 result = (wxDateTime *) &_result_ref;
22557 }
22558
22559 wxPyEndAllowThreads(__tstate);
22560 if (PyErr_Occurred()) SWIG_fail;
22561 }
22562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj;
22571 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22572 wxDateTime *arg2 = 0 ;
22573 PyObject * obj0 = 0 ;
22574 PyObject * obj1 = 0 ;
22575 char *kwnames[] = {
22576 (char *) "self",(char *) "date", NULL
22577 };
22578
22579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22581 if (SWIG_arg_fail(1)) SWIG_fail;
22582 {
22583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22584 if (SWIG_arg_fail(2)) SWIG_fail;
22585 if (arg2 == NULL) {
22586 SWIG_null_ref("wxDateTime");
22587 }
22588 if (SWIG_arg_fail(2)) SWIG_fail;
22589 }
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 (arg1)->SetDate((wxDateTime const &)*arg2);
22593
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 Py_INCREF(Py_None); resultobj = Py_None;
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22605 PyObject *obj;
22606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22607 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22608 Py_INCREF(obj);
22609 return Py_BuildValue((char *)"");
22610 }
22611 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22612 PyObject *resultobj;
22613 wxPyApp *result;
22614 char *kwnames[] = {
22615 NULL
22616 };
22617
22618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 result = (wxPyApp *)new_wxPyApp();
22622
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj;
22635 wxPyApp *arg1 = (wxPyApp *) 0 ;
22636 PyObject * obj0 = 0 ;
22637 char *kwnames[] = {
22638 (char *) "self", NULL
22639 };
22640
22641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22643 if (SWIG_arg_fail(1)) SWIG_fail;
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 delete arg1;
22647
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 Py_INCREF(Py_None); resultobj = Py_None;
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22659 PyObject *resultobj;
22660 wxPyApp *arg1 = (wxPyApp *) 0 ;
22661 PyObject *arg2 = (PyObject *) 0 ;
22662 PyObject *arg3 = (PyObject *) 0 ;
22663 PyObject * obj0 = 0 ;
22664 PyObject * obj1 = 0 ;
22665 PyObject * obj2 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self",(char *) "self",(char *) "_class", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 arg2 = obj1;
22674 arg3 = obj2;
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 (arg1)->_setCallbackInfo(arg2,arg3);
22678
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 Py_INCREF(Py_None); resultobj = Py_None;
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj;
22691 wxPyApp *arg1 = (wxPyApp *) 0 ;
22692 wxString result;
22693 PyObject * obj0 = 0 ;
22694 char *kwnames[] = {
22695 (char *) "self", NULL
22696 };
22697
22698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22700 if (SWIG_arg_fail(1)) SWIG_fail;
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 result = ((wxPyApp const *)arg1)->GetAppName();
22704
22705 wxPyEndAllowThreads(__tstate);
22706 if (PyErr_Occurred()) SWIG_fail;
22707 }
22708 {
22709 #if wxUSE_UNICODE
22710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22711 #else
22712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22713 #endif
22714 }
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22722 PyObject *resultobj;
22723 wxPyApp *arg1 = (wxPyApp *) 0 ;
22724 wxString *arg2 = 0 ;
22725 bool temp2 = false ;
22726 PyObject * obj0 = 0 ;
22727 PyObject * obj1 = 0 ;
22728 char *kwnames[] = {
22729 (char *) "self",(char *) "name", NULL
22730 };
22731
22732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22734 if (SWIG_arg_fail(1)) SWIG_fail;
22735 {
22736 arg2 = wxString_in_helper(obj1);
22737 if (arg2 == NULL) SWIG_fail;
22738 temp2 = true;
22739 }
22740 {
22741 PyThreadState* __tstate = wxPyBeginAllowThreads();
22742 (arg1)->SetAppName((wxString const &)*arg2);
22743
22744 wxPyEndAllowThreads(__tstate);
22745 if (PyErr_Occurred()) SWIG_fail;
22746 }
22747 Py_INCREF(Py_None); resultobj = Py_None;
22748 {
22749 if (temp2)
22750 delete arg2;
22751 }
22752 return resultobj;
22753 fail:
22754 {
22755 if (temp2)
22756 delete arg2;
22757 }
22758 return NULL;
22759 }
22760
22761
22762 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22763 PyObject *resultobj;
22764 wxPyApp *arg1 = (wxPyApp *) 0 ;
22765 wxString result;
22766 PyObject * obj0 = 0 ;
22767 char *kwnames[] = {
22768 (char *) "self", NULL
22769 };
22770
22771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22773 if (SWIG_arg_fail(1)) SWIG_fail;
22774 {
22775 PyThreadState* __tstate = wxPyBeginAllowThreads();
22776 result = ((wxPyApp const *)arg1)->GetClassName();
22777
22778 wxPyEndAllowThreads(__tstate);
22779 if (PyErr_Occurred()) SWIG_fail;
22780 }
22781 {
22782 #if wxUSE_UNICODE
22783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22784 #else
22785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22786 #endif
22787 }
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22795 PyObject *resultobj;
22796 wxPyApp *arg1 = (wxPyApp *) 0 ;
22797 wxString *arg2 = 0 ;
22798 bool temp2 = false ;
22799 PyObject * obj0 = 0 ;
22800 PyObject * obj1 = 0 ;
22801 char *kwnames[] = {
22802 (char *) "self",(char *) "name", NULL
22803 };
22804
22805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(1)) SWIG_fail;
22808 {
22809 arg2 = wxString_in_helper(obj1);
22810 if (arg2 == NULL) SWIG_fail;
22811 temp2 = true;
22812 }
22813 {
22814 PyThreadState* __tstate = wxPyBeginAllowThreads();
22815 (arg1)->SetClassName((wxString const &)*arg2);
22816
22817 wxPyEndAllowThreads(__tstate);
22818 if (PyErr_Occurred()) SWIG_fail;
22819 }
22820 Py_INCREF(Py_None); resultobj = Py_None;
22821 {
22822 if (temp2)
22823 delete arg2;
22824 }
22825 return resultobj;
22826 fail:
22827 {
22828 if (temp2)
22829 delete arg2;
22830 }
22831 return NULL;
22832 }
22833
22834
22835 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22836 PyObject *resultobj;
22837 wxPyApp *arg1 = (wxPyApp *) 0 ;
22838 wxString *result;
22839 PyObject * obj0 = 0 ;
22840 char *kwnames[] = {
22841 (char *) "self", NULL
22842 };
22843
22844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22846 if (SWIG_arg_fail(1)) SWIG_fail;
22847 {
22848 PyThreadState* __tstate = wxPyBeginAllowThreads();
22849 {
22850 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22851 result = (wxString *) &_result_ref;
22852 }
22853
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 {
22858 #if wxUSE_UNICODE
22859 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22860 #else
22861 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22862 #endif
22863 }
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 wxPyApp *arg1 = (wxPyApp *) 0 ;
22873 wxString *arg2 = 0 ;
22874 bool temp2 = false ;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877 char *kwnames[] = {
22878 (char *) "self",(char *) "name", NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(1)) SWIG_fail;
22884 {
22885 arg2 = wxString_in_helper(obj1);
22886 if (arg2 == NULL) SWIG_fail;
22887 temp2 = true;
22888 }
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 (arg1)->SetVendorName((wxString const &)*arg2);
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 Py_INCREF(Py_None); resultobj = Py_None;
22897 {
22898 if (temp2)
22899 delete arg2;
22900 }
22901 return resultobj;
22902 fail:
22903 {
22904 if (temp2)
22905 delete arg2;
22906 }
22907 return NULL;
22908 }
22909
22910
22911 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj;
22913 wxPyApp *arg1 = (wxPyApp *) 0 ;
22914 wxAppTraits *result;
22915 PyObject * obj0 = 0 ;
22916 char *kwnames[] = {
22917 (char *) "self", NULL
22918 };
22919
22920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22922 if (SWIG_arg_fail(1)) SWIG_fail;
22923 {
22924 PyThreadState* __tstate = wxPyBeginAllowThreads();
22925 result = (wxAppTraits *)(arg1)->GetTraits();
22926
22927 wxPyEndAllowThreads(__tstate);
22928 if (PyErr_Occurred()) SWIG_fail;
22929 }
22930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22931 return resultobj;
22932 fail:
22933 return NULL;
22934 }
22935
22936
22937 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22938 PyObject *resultobj;
22939 wxPyApp *arg1 = (wxPyApp *) 0 ;
22940 PyObject * obj0 = 0 ;
22941 char *kwnames[] = {
22942 (char *) "self", NULL
22943 };
22944
22945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22947 if (SWIG_arg_fail(1)) SWIG_fail;
22948 {
22949 PyThreadState* __tstate = wxPyBeginAllowThreads();
22950 (arg1)->ProcessPendingEvents();
22951
22952 wxPyEndAllowThreads(__tstate);
22953 if (PyErr_Occurred()) SWIG_fail;
22954 }
22955 Py_INCREF(Py_None); resultobj = Py_None;
22956 return resultobj;
22957 fail:
22958 return NULL;
22959 }
22960
22961
22962 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22963 PyObject *resultobj;
22964 wxPyApp *arg1 = (wxPyApp *) 0 ;
22965 bool arg2 = (bool) false ;
22966 bool result;
22967 PyObject * obj0 = 0 ;
22968 PyObject * obj1 = 0 ;
22969 char *kwnames[] = {
22970 (char *) "self",(char *) "onlyIfNeeded", NULL
22971 };
22972
22973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22975 if (SWIG_arg_fail(1)) SWIG_fail;
22976 if (obj1) {
22977 {
22978 arg2 = (bool)(SWIG_As_bool(obj1));
22979 if (SWIG_arg_fail(2)) SWIG_fail;
22980 }
22981 }
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = (bool)(arg1)->Yield(arg2);
22985
22986 wxPyEndAllowThreads(__tstate);
22987 if (PyErr_Occurred()) SWIG_fail;
22988 }
22989 {
22990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22991 }
22992 return resultobj;
22993 fail:
22994 return NULL;
22995 }
22996
22997
22998 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22999 PyObject *resultobj;
23000 wxPyApp *arg1 = (wxPyApp *) 0 ;
23001 PyObject * obj0 = 0 ;
23002 char *kwnames[] = {
23003 (char *) "self", NULL
23004 };
23005
23006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23008 if (SWIG_arg_fail(1)) SWIG_fail;
23009 {
23010 PyThreadState* __tstate = wxPyBeginAllowThreads();
23011 (arg1)->WakeUpIdle();
23012
23013 wxPyEndAllowThreads(__tstate);
23014 if (PyErr_Occurred()) SWIG_fail;
23015 }
23016 Py_INCREF(Py_None); resultobj = Py_None;
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23024 PyObject *resultobj;
23025 bool result;
23026 char *kwnames[] = {
23027 NULL
23028 };
23029
23030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 result = (bool)wxPyApp::IsMainLoopRunning();
23034
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 {
23039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23040 }
23041 return resultobj;
23042 fail:
23043 return NULL;
23044 }
23045
23046
23047 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj;
23049 wxPyApp *arg1 = (wxPyApp *) 0 ;
23050 int result;
23051 PyObject * obj0 = 0 ;
23052 char *kwnames[] = {
23053 (char *) "self", NULL
23054 };
23055
23056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 result = (int)(arg1)->MainLoop();
23062
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 resultobj = SWIG_From_int((int)(result));
23068 }
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23076 PyObject *resultobj;
23077 wxPyApp *arg1 = (wxPyApp *) 0 ;
23078 PyObject * obj0 = 0 ;
23079 char *kwnames[] = {
23080 (char *) "self", NULL
23081 };
23082
23083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23085 if (SWIG_arg_fail(1)) SWIG_fail;
23086 {
23087 PyThreadState* __tstate = wxPyBeginAllowThreads();
23088 (arg1)->Exit();
23089
23090 wxPyEndAllowThreads(__tstate);
23091 if (PyErr_Occurred()) SWIG_fail;
23092 }
23093 Py_INCREF(Py_None); resultobj = Py_None;
23094 return resultobj;
23095 fail:
23096 return NULL;
23097 }
23098
23099
23100 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23101 PyObject *resultobj;
23102 wxPyApp *arg1 = (wxPyApp *) 0 ;
23103 PyObject * obj0 = 0 ;
23104 char *kwnames[] = {
23105 (char *) "self", NULL
23106 };
23107
23108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23110 if (SWIG_arg_fail(1)) SWIG_fail;
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 (arg1)->ExitMainLoop();
23114
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 Py_INCREF(Py_None); resultobj = Py_None;
23119 return resultobj;
23120 fail:
23121 return NULL;
23122 }
23123
23124
23125 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23126 PyObject *resultobj;
23127 wxPyApp *arg1 = (wxPyApp *) 0 ;
23128 bool result;
23129 PyObject * obj0 = 0 ;
23130 char *kwnames[] = {
23131 (char *) "self", NULL
23132 };
23133
23134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23136 if (SWIG_arg_fail(1)) SWIG_fail;
23137 {
23138 PyThreadState* __tstate = wxPyBeginAllowThreads();
23139 result = (bool)(arg1)->Pending();
23140
23141 wxPyEndAllowThreads(__tstate);
23142 if (PyErr_Occurred()) SWIG_fail;
23143 }
23144 {
23145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23146 }
23147 return resultobj;
23148 fail:
23149 return NULL;
23150 }
23151
23152
23153 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23154 PyObject *resultobj;
23155 wxPyApp *arg1 = (wxPyApp *) 0 ;
23156 bool result;
23157 PyObject * obj0 = 0 ;
23158 char *kwnames[] = {
23159 (char *) "self", NULL
23160 };
23161
23162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23164 if (SWIG_arg_fail(1)) SWIG_fail;
23165 {
23166 PyThreadState* __tstate = wxPyBeginAllowThreads();
23167 result = (bool)(arg1)->Dispatch();
23168
23169 wxPyEndAllowThreads(__tstate);
23170 if (PyErr_Occurred()) SWIG_fail;
23171 }
23172 {
23173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23174 }
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj;
23183 wxPyApp *arg1 = (wxPyApp *) 0 ;
23184 bool result;
23185 PyObject * obj0 = 0 ;
23186 char *kwnames[] = {
23187 (char *) "self", NULL
23188 };
23189
23190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23192 if (SWIG_arg_fail(1)) SWIG_fail;
23193 {
23194 PyThreadState* __tstate = wxPyBeginAllowThreads();
23195 result = (bool)(arg1)->ProcessIdle();
23196
23197 wxPyEndAllowThreads(__tstate);
23198 if (PyErr_Occurred()) SWIG_fail;
23199 }
23200 {
23201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23202 }
23203 return resultobj;
23204 fail:
23205 return NULL;
23206 }
23207
23208
23209 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23210 PyObject *resultobj;
23211 wxPyApp *arg1 = (wxPyApp *) 0 ;
23212 wxWindow *arg2 = (wxWindow *) 0 ;
23213 wxIdleEvent *arg3 = 0 ;
23214 bool result;
23215 PyObject * obj0 = 0 ;
23216 PyObject * obj1 = 0 ;
23217 PyObject * obj2 = 0 ;
23218 char *kwnames[] = {
23219 (char *) "self",(char *) "win",(char *) "event", NULL
23220 };
23221
23222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23224 if (SWIG_arg_fail(1)) SWIG_fail;
23225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23226 if (SWIG_arg_fail(2)) SWIG_fail;
23227 {
23228 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23229 if (SWIG_arg_fail(3)) SWIG_fail;
23230 if (arg3 == NULL) {
23231 SWIG_null_ref("wxIdleEvent");
23232 }
23233 if (SWIG_arg_fail(3)) SWIG_fail;
23234 }
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23238
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 {
23243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23244 }
23245 return resultobj;
23246 fail:
23247 return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23252 PyObject *resultobj;
23253 wxPyApp *arg1 = (wxPyApp *) 0 ;
23254 bool result;
23255 PyObject * obj0 = 0 ;
23256 char *kwnames[] = {
23257 (char *) "self", NULL
23258 };
23259
23260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23262 if (SWIG_arg_fail(1)) SWIG_fail;
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 result = (bool)((wxPyApp const *)arg1)->IsActive();
23266
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 {
23271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23272 }
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj;
23281 wxPyApp *arg1 = (wxPyApp *) 0 ;
23282 wxWindow *arg2 = (wxWindow *) 0 ;
23283 PyObject * obj0 = 0 ;
23284 PyObject * obj1 = 0 ;
23285 char *kwnames[] = {
23286 (char *) "self",(char *) "win", NULL
23287 };
23288
23289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23291 if (SWIG_arg_fail(1)) SWIG_fail;
23292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23293 if (SWIG_arg_fail(2)) SWIG_fail;
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 (arg1)->SetTopWindow(arg2);
23297
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 Py_INCREF(Py_None); resultobj = Py_None;
23302 return resultobj;
23303 fail:
23304 return NULL;
23305 }
23306
23307
23308 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23309 PyObject *resultobj;
23310 wxPyApp *arg1 = (wxPyApp *) 0 ;
23311 wxWindow *result;
23312 PyObject * obj0 = 0 ;
23313 char *kwnames[] = {
23314 (char *) "self", NULL
23315 };
23316
23317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23319 if (SWIG_arg_fail(1)) SWIG_fail;
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23323
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 {
23328 resultobj = wxPyMake_wxObject(result, 0);
23329 }
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj;
23338 wxPyApp *arg1 = (wxPyApp *) 0 ;
23339 bool arg2 ;
23340 PyObject * obj0 = 0 ;
23341 PyObject * obj1 = 0 ;
23342 char *kwnames[] = {
23343 (char *) "self",(char *) "flag", NULL
23344 };
23345
23346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23348 if (SWIG_arg_fail(1)) SWIG_fail;
23349 {
23350 arg2 = (bool)(SWIG_As_bool(obj1));
23351 if (SWIG_arg_fail(2)) SWIG_fail;
23352 }
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 (arg1)->SetExitOnFrameDelete(arg2);
23356
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 Py_INCREF(Py_None); resultobj = Py_None;
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj;
23369 wxPyApp *arg1 = (wxPyApp *) 0 ;
23370 bool result;
23371 PyObject * obj0 = 0 ;
23372 char *kwnames[] = {
23373 (char *) "self", NULL
23374 };
23375
23376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23378 if (SWIG_arg_fail(1)) SWIG_fail;
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23382
23383 wxPyEndAllowThreads(__tstate);
23384 if (PyErr_Occurred()) SWIG_fail;
23385 }
23386 {
23387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23388 }
23389 return resultobj;
23390 fail:
23391 return NULL;
23392 }
23393
23394
23395 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23396 PyObject *resultobj;
23397 wxPyApp *arg1 = (wxPyApp *) 0 ;
23398 bool arg2 ;
23399 PyObject * obj0 = 0 ;
23400 PyObject * obj1 = 0 ;
23401 char *kwnames[] = {
23402 (char *) "self",(char *) "flag", NULL
23403 };
23404
23405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23407 if (SWIG_arg_fail(1)) SWIG_fail;
23408 {
23409 arg2 = (bool)(SWIG_As_bool(obj1));
23410 if (SWIG_arg_fail(2)) SWIG_fail;
23411 }
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 (arg1)->SetUseBestVisual(arg2);
23415
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 Py_INCREF(Py_None); resultobj = Py_None;
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj;
23428 wxPyApp *arg1 = (wxPyApp *) 0 ;
23429 bool result;
23430 PyObject * obj0 = 0 ;
23431 char *kwnames[] = {
23432 (char *) "self", NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23437 if (SWIG_arg_fail(1)) SWIG_fail;
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23441
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 {
23446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23447 }
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj;
23456 wxPyApp *arg1 = (wxPyApp *) 0 ;
23457 int arg2 ;
23458 PyObject * obj0 = 0 ;
23459 PyObject * obj1 = 0 ;
23460 char *kwnames[] = {
23461 (char *) "self",(char *) "mode", NULL
23462 };
23463
23464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23466 if (SWIG_arg_fail(1)) SWIG_fail;
23467 {
23468 arg2 = (int)(SWIG_As_int(obj1));
23469 if (SWIG_arg_fail(2)) SWIG_fail;
23470 }
23471 {
23472 PyThreadState* __tstate = wxPyBeginAllowThreads();
23473 (arg1)->SetPrintMode(arg2);
23474
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 Py_INCREF(Py_None); resultobj = Py_None;
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj;
23487 wxPyApp *arg1 = (wxPyApp *) 0 ;
23488 int result;
23489 PyObject * obj0 = 0 ;
23490 char *kwnames[] = {
23491 (char *) "self", NULL
23492 };
23493
23494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23496 if (SWIG_arg_fail(1)) SWIG_fail;
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23500
23501 wxPyEndAllowThreads(__tstate);
23502 if (PyErr_Occurred()) SWIG_fail;
23503 }
23504 {
23505 resultobj = SWIG_From_int((int)(result));
23506 }
23507 return resultobj;
23508 fail:
23509 return NULL;
23510 }
23511
23512
23513 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23514 PyObject *resultobj;
23515 wxPyApp *arg1 = (wxPyApp *) 0 ;
23516 int arg2 ;
23517 PyObject * obj0 = 0 ;
23518 PyObject * obj1 = 0 ;
23519 char *kwnames[] = {
23520 (char *) "self",(char *) "mode", NULL
23521 };
23522
23523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23525 if (SWIG_arg_fail(1)) SWIG_fail;
23526 {
23527 arg2 = (int)(SWIG_As_int(obj1));
23528 if (SWIG_arg_fail(2)) SWIG_fail;
23529 }
23530 {
23531 PyThreadState* __tstate = wxPyBeginAllowThreads();
23532 (arg1)->SetAssertMode(arg2);
23533
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 Py_INCREF(Py_None); resultobj = Py_None;
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj;
23546 wxPyApp *arg1 = (wxPyApp *) 0 ;
23547 int result;
23548 PyObject * obj0 = 0 ;
23549 char *kwnames[] = {
23550 (char *) "self", NULL
23551 };
23552
23553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23555 if (SWIG_arg_fail(1)) SWIG_fail;
23556 {
23557 PyThreadState* __tstate = wxPyBeginAllowThreads();
23558 result = (int)(arg1)->GetAssertMode();
23559
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 resultobj = SWIG_From_int((int)(result));
23565 }
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23573 PyObject *resultobj;
23574 bool result;
23575 char *kwnames[] = {
23576 NULL
23577 };
23578
23579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23580 {
23581 PyThreadState* __tstate = wxPyBeginAllowThreads();
23582 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23583
23584 wxPyEndAllowThreads(__tstate);
23585 if (PyErr_Occurred()) SWIG_fail;
23586 }
23587 {
23588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23589 }
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj;
23598 long result;
23599 char *kwnames[] = {
23600 NULL
23601 };
23602
23603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (long)wxPyApp::GetMacAboutMenuItemId();
23607
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 {
23612 resultobj = SWIG_From_long((long)(result));
23613 }
23614 return resultobj;
23615 fail:
23616 return NULL;
23617 }
23618
23619
23620 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23621 PyObject *resultobj;
23622 long result;
23623 char *kwnames[] = {
23624 NULL
23625 };
23626
23627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23631
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 {
23636 resultobj = SWIG_From_long((long)(result));
23637 }
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23645 PyObject *resultobj;
23646 long result;
23647 char *kwnames[] = {
23648 NULL
23649 };
23650
23651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = (long)wxPyApp::GetMacExitMenuItemId();
23655
23656 wxPyEndAllowThreads(__tstate);
23657 if (PyErr_Occurred()) SWIG_fail;
23658 }
23659 {
23660 resultobj = SWIG_From_long((long)(result));
23661 }
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj;
23670 wxString result;
23671 char *kwnames[] = {
23672 NULL
23673 };
23674
23675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23676 {
23677 PyThreadState* __tstate = wxPyBeginAllowThreads();
23678 result = wxPyApp::GetMacHelpMenuTitleName();
23679
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 {
23684 #if wxUSE_UNICODE
23685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23686 #else
23687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23688 #endif
23689 }
23690 return resultobj;
23691 fail:
23692 return NULL;
23693 }
23694
23695
23696 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23697 PyObject *resultobj;
23698 bool arg1 ;
23699 PyObject * obj0 = 0 ;
23700 char *kwnames[] = {
23701 (char *) "val", NULL
23702 };
23703
23704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23705 {
23706 arg1 = (bool)(SWIG_As_bool(obj0));
23707 if (SWIG_arg_fail(1)) SWIG_fail;
23708 }
23709 {
23710 PyThreadState* __tstate = wxPyBeginAllowThreads();
23711 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23712
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 Py_INCREF(Py_None); resultobj = Py_None;
23717 return resultobj;
23718 fail:
23719 return NULL;
23720 }
23721
23722
23723 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23724 PyObject *resultobj;
23725 long arg1 ;
23726 PyObject * obj0 = 0 ;
23727 char *kwnames[] = {
23728 (char *) "val", NULL
23729 };
23730
23731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23732 {
23733 arg1 = (long)(SWIG_As_long(obj0));
23734 if (SWIG_arg_fail(1)) SWIG_fail;
23735 }
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 wxPyApp::SetMacAboutMenuItemId(arg1);
23739
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 Py_INCREF(Py_None); resultobj = Py_None;
23744 return resultobj;
23745 fail:
23746 return NULL;
23747 }
23748
23749
23750 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23751 PyObject *resultobj;
23752 long arg1 ;
23753 PyObject * obj0 = 0 ;
23754 char *kwnames[] = {
23755 (char *) "val", NULL
23756 };
23757
23758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23759 {
23760 arg1 = (long)(SWIG_As_long(obj0));
23761 if (SWIG_arg_fail(1)) SWIG_fail;
23762 }
23763 {
23764 PyThreadState* __tstate = wxPyBeginAllowThreads();
23765 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23766
23767 wxPyEndAllowThreads(__tstate);
23768 if (PyErr_Occurred()) SWIG_fail;
23769 }
23770 Py_INCREF(Py_None); resultobj = Py_None;
23771 return resultobj;
23772 fail:
23773 return NULL;
23774 }
23775
23776
23777 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23778 PyObject *resultobj;
23779 long arg1 ;
23780 PyObject * obj0 = 0 ;
23781 char *kwnames[] = {
23782 (char *) "val", NULL
23783 };
23784
23785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23786 {
23787 arg1 = (long)(SWIG_As_long(obj0));
23788 if (SWIG_arg_fail(1)) SWIG_fail;
23789 }
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 wxPyApp::SetMacExitMenuItemId(arg1);
23793
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 Py_INCREF(Py_None); resultobj = Py_None;
23798 return resultobj;
23799 fail:
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj;
23806 wxString *arg1 = 0 ;
23807 bool temp1 = false ;
23808 PyObject * obj0 = 0 ;
23809 char *kwnames[] = {
23810 (char *) "val", NULL
23811 };
23812
23813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23814 {
23815 arg1 = wxString_in_helper(obj0);
23816 if (arg1 == NULL) SWIG_fail;
23817 temp1 = true;
23818 }
23819 {
23820 PyThreadState* __tstate = wxPyBeginAllowThreads();
23821 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23822
23823 wxPyEndAllowThreads(__tstate);
23824 if (PyErr_Occurred()) SWIG_fail;
23825 }
23826 Py_INCREF(Py_None); resultobj = Py_None;
23827 {
23828 if (temp1)
23829 delete arg1;
23830 }
23831 return resultobj;
23832 fail:
23833 {
23834 if (temp1)
23835 delete arg1;
23836 }
23837 return NULL;
23838 }
23839
23840
23841 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23842 PyObject *resultobj;
23843 wxPyApp *arg1 = (wxPyApp *) 0 ;
23844 PyObject * obj0 = 0 ;
23845 char *kwnames[] = {
23846 (char *) "self", NULL
23847 };
23848
23849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23851 if (SWIG_arg_fail(1)) SWIG_fail;
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 (arg1)->_BootstrapApp();
23855
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 Py_INCREF(Py_None); resultobj = Py_None;
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23867 PyObject *resultobj;
23868 int result;
23869 char *kwnames[] = {
23870 NULL
23871 };
23872
23873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = (int)wxPyApp::GetComCtl32Version();
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 {
23882 resultobj = SWIG_From_int((int)(result));
23883 }
23884 return resultobj;
23885 fail:
23886 return NULL;
23887 }
23888
23889
23890 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23891 PyObject *obj;
23892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23893 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23894 Py_INCREF(obj);
23895 return Py_BuildValue((char *)"");
23896 }
23897 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23898 PyObject *resultobj;
23899 char *kwnames[] = {
23900 NULL
23901 };
23902
23903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 wxExit();
23907
23908 wxPyEndAllowThreads(__tstate);
23909 if (PyErr_Occurred()) SWIG_fail;
23910 }
23911 Py_INCREF(Py_None); resultobj = Py_None;
23912 return resultobj;
23913 fail:
23914 return NULL;
23915 }
23916
23917
23918 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23919 PyObject *resultobj;
23920 bool result;
23921 char *kwnames[] = {
23922 NULL
23923 };
23924
23925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 result = (bool)wxYield();
23929
23930 wxPyEndAllowThreads(__tstate);
23931 if (PyErr_Occurred()) SWIG_fail;
23932 }
23933 {
23934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23935 }
23936 return resultobj;
23937 fail:
23938 return NULL;
23939 }
23940
23941
23942 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23943 PyObject *resultobj;
23944 bool result;
23945 char *kwnames[] = {
23946 NULL
23947 };
23948
23949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 result = (bool)wxYieldIfNeeded();
23953
23954 wxPyEndAllowThreads(__tstate);
23955 if (PyErr_Occurred()) SWIG_fail;
23956 }
23957 {
23958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23959 }
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj;
23968 wxWindow *arg1 = (wxWindow *) NULL ;
23969 bool arg2 = (bool) false ;
23970 bool result;
23971 PyObject * obj0 = 0 ;
23972 PyObject * obj1 = 0 ;
23973 char *kwnames[] = {
23974 (char *) "win",(char *) "onlyIfNeeded", NULL
23975 };
23976
23977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23978 if (obj0) {
23979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23980 if (SWIG_arg_fail(1)) SWIG_fail;
23981 }
23982 if (obj1) {
23983 {
23984 arg2 = (bool)(SWIG_As_bool(obj1));
23985 if (SWIG_arg_fail(2)) SWIG_fail;
23986 }
23987 }
23988 {
23989 PyThreadState* __tstate = wxPyBeginAllowThreads();
23990 result = (bool)wxSafeYield(arg1,arg2);
23991
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 {
23996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23997 }
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24005 PyObject *resultobj;
24006 char *kwnames[] = {
24007 NULL
24008 };
24009
24010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 wxWakeUpIdle();
24014
24015 wxPyEndAllowThreads(__tstate);
24016 if (PyErr_Occurred()) SWIG_fail;
24017 }
24018 Py_INCREF(Py_None); resultobj = Py_None;
24019 return resultobj;
24020 fail:
24021 return NULL;
24022 }
24023
24024
24025 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24026 PyObject *resultobj;
24027 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24028 wxEvent *arg2 = 0 ;
24029 PyObject * obj0 = 0 ;
24030 PyObject * obj1 = 0 ;
24031 char *kwnames[] = {
24032 (char *) "dest",(char *) "event", NULL
24033 };
24034
24035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24037 if (SWIG_arg_fail(1)) SWIG_fail;
24038 {
24039 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24040 if (SWIG_arg_fail(2)) SWIG_fail;
24041 if (arg2 == NULL) {
24042 SWIG_null_ref("wxEvent");
24043 }
24044 if (SWIG_arg_fail(2)) SWIG_fail;
24045 }
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 wxPostEvent(arg1,*arg2);
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 Py_INCREF(Py_None); resultobj = Py_None;
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 char *kwnames[] = {
24063 NULL
24064 };
24065
24066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24067 {
24068 PyThreadState* __tstate = wxPyBeginAllowThreads();
24069 wxApp_CleanUp();
24070
24071 wxPyEndAllowThreads(__tstate);
24072 if (PyErr_Occurred()) SWIG_fail;
24073 }
24074 Py_INCREF(Py_None); resultobj = Py_None;
24075 return resultobj;
24076 fail:
24077 return NULL;
24078 }
24079
24080
24081 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24082 PyObject *resultobj;
24083 wxPyApp *result;
24084 char *kwnames[] = {
24085 NULL
24086 };
24087
24088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 result = (wxPyApp *)wxPyGetApp();
24092
24093 wxPyEndAllowThreads(__tstate);
24094 if (PyErr_Occurred()) SWIG_fail;
24095 }
24096 {
24097 resultobj = wxPyMake_wxObject(result, 0);
24098 }
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj;
24107 char *arg1 = (char *) 0 ;
24108 PyObject * obj0 = 0 ;
24109 char *kwnames[] = {
24110 (char *) "encoding", NULL
24111 };
24112
24113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24114 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24115 SWIG_arg_fail(1);SWIG_fail;
24116 }
24117 {
24118 PyThreadState* __tstate = wxPyBeginAllowThreads();
24119 wxSetDefaultPyEncoding((char const *)arg1);
24120
24121 wxPyEndAllowThreads(__tstate);
24122 if (PyErr_Occurred()) SWIG_fail;
24123 }
24124 Py_INCREF(Py_None); resultobj = Py_None;
24125 return resultobj;
24126 fail:
24127 return NULL;
24128 }
24129
24130
24131 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj;
24133 char *result;
24134 char *kwnames[] = {
24135 NULL
24136 };
24137
24138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 result = (char *)wxGetDefaultPyEncoding();
24142
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 resultobj = SWIG_FromCharPtr(result);
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24154 PyObject *resultobj;
24155 wxEventLoop *result;
24156 char *kwnames[] = {
24157 NULL
24158 };
24159
24160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 result = (wxEventLoop *)new wxEventLoop();
24164
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24176 PyObject *resultobj;
24177 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24178 PyObject * obj0 = 0 ;
24179 char *kwnames[] = {
24180 (char *) "self", NULL
24181 };
24182
24183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24185 if (SWIG_arg_fail(1)) SWIG_fail;
24186 {
24187 PyThreadState* __tstate = wxPyBeginAllowThreads();
24188 delete arg1;
24189
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 Py_INCREF(Py_None); resultobj = Py_None;
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24201 PyObject *resultobj;
24202 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24203 int result;
24204 PyObject * obj0 = 0 ;
24205 char *kwnames[] = {
24206 (char *) "self", NULL
24207 };
24208
24209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24211 if (SWIG_arg_fail(1)) SWIG_fail;
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 result = (int)(arg1)->Run();
24215
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 {
24220 resultobj = SWIG_From_int((int)(result));
24221 }
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj;
24230 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24231 int arg2 = (int) 0 ;
24232 PyObject * obj0 = 0 ;
24233 PyObject * obj1 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "self",(char *) "rc", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24240 if (SWIG_arg_fail(1)) SWIG_fail;
24241 if (obj1) {
24242 {
24243 arg2 = (int)(SWIG_As_int(obj1));
24244 if (SWIG_arg_fail(2)) SWIG_fail;
24245 }
24246 }
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 (arg1)->Exit(arg2);
24250
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 Py_INCREF(Py_None); resultobj = Py_None;
24255 return resultobj;
24256 fail:
24257 return NULL;
24258 }
24259
24260
24261 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24262 PyObject *resultobj;
24263 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24264 bool result;
24265 PyObject * obj0 = 0 ;
24266 char *kwnames[] = {
24267 (char *) "self", NULL
24268 };
24269
24270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24272 if (SWIG_arg_fail(1)) SWIG_fail;
24273 {
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (bool)((wxEventLoop const *)arg1)->Pending();
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 {
24281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24282 }
24283 return resultobj;
24284 fail:
24285 return NULL;
24286 }
24287
24288
24289 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24290 PyObject *resultobj;
24291 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24292 bool result;
24293 PyObject * obj0 = 0 ;
24294 char *kwnames[] = {
24295 (char *) "self", NULL
24296 };
24297
24298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24300 if (SWIG_arg_fail(1)) SWIG_fail;
24301 {
24302 PyThreadState* __tstate = wxPyBeginAllowThreads();
24303 result = (bool)(arg1)->Dispatch();
24304
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 {
24309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24310 }
24311 return resultobj;
24312 fail:
24313 return NULL;
24314 }
24315
24316
24317 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24318 PyObject *resultobj;
24319 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24320 bool result;
24321 PyObject * obj0 = 0 ;
24322 char *kwnames[] = {
24323 (char *) "self", NULL
24324 };
24325
24326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24328 if (SWIG_arg_fail(1)) SWIG_fail;
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24332
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 {
24337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24338 }
24339 return resultobj;
24340 fail:
24341 return NULL;
24342 }
24343
24344
24345 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24346 PyObject *resultobj;
24347 wxEventLoop *result;
24348 char *kwnames[] = {
24349 NULL
24350 };
24351
24352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (wxEventLoop *)wxEventLoop::GetActive();
24356
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj;
24369 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24370 PyObject * obj0 = 0 ;
24371 char *kwnames[] = {
24372 (char *) "loop", NULL
24373 };
24374
24375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24377 if (SWIG_arg_fail(1)) SWIG_fail;
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 wxEventLoop::SetActive(arg1);
24381
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 Py_INCREF(Py_None); resultobj = Py_None;
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24393 PyObject *obj;
24394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24395 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24396 Py_INCREF(obj);
24397 return Py_BuildValue((char *)"");
24398 }
24399 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24400 PyObject *resultobj;
24401 int arg1 = (int) 0 ;
24402 int arg2 = (int) 0 ;
24403 int arg3 = (int) 0 ;
24404 wxAcceleratorEntry *result;
24405 PyObject * obj0 = 0 ;
24406 PyObject * obj1 = 0 ;
24407 PyObject * obj2 = 0 ;
24408 char *kwnames[] = {
24409 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24410 };
24411
24412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24413 if (obj0) {
24414 {
24415 arg1 = (int)(SWIG_As_int(obj0));
24416 if (SWIG_arg_fail(1)) SWIG_fail;
24417 }
24418 }
24419 if (obj1) {
24420 {
24421 arg2 = (int)(SWIG_As_int(obj1));
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 }
24425 if (obj2) {
24426 {
24427 arg3 = (int)(SWIG_As_int(obj2));
24428 if (SWIG_arg_fail(3)) SWIG_fail;
24429 }
24430 }
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24434
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24446 PyObject *resultobj;
24447 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24448 PyObject * obj0 = 0 ;
24449 char *kwnames[] = {
24450 (char *) "self", NULL
24451 };
24452
24453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24455 if (SWIG_arg_fail(1)) SWIG_fail;
24456 {
24457 PyThreadState* __tstate = wxPyBeginAllowThreads();
24458 delete arg1;
24459
24460 wxPyEndAllowThreads(__tstate);
24461 if (PyErr_Occurred()) SWIG_fail;
24462 }
24463 Py_INCREF(Py_None); resultobj = Py_None;
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24473 int arg2 ;
24474 int arg3 ;
24475 int arg4 ;
24476 PyObject * obj0 = 0 ;
24477 PyObject * obj1 = 0 ;
24478 PyObject * obj2 = 0 ;
24479 PyObject * obj3 = 0 ;
24480 char *kwnames[] = {
24481 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24482 };
24483
24484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24486 if (SWIG_arg_fail(1)) SWIG_fail;
24487 {
24488 arg2 = (int)(SWIG_As_int(obj1));
24489 if (SWIG_arg_fail(2)) SWIG_fail;
24490 }
24491 {
24492 arg3 = (int)(SWIG_As_int(obj2));
24493 if (SWIG_arg_fail(3)) SWIG_fail;
24494 }
24495 {
24496 arg4 = (int)(SWIG_As_int(obj3));
24497 if (SWIG_arg_fail(4)) SWIG_fail;
24498 }
24499 {
24500 PyThreadState* __tstate = wxPyBeginAllowThreads();
24501 (arg1)->Set(arg2,arg3,arg4);
24502
24503 wxPyEndAllowThreads(__tstate);
24504 if (PyErr_Occurred()) SWIG_fail;
24505 }
24506 Py_INCREF(Py_None); resultobj = Py_None;
24507 return resultobj;
24508 fail:
24509 return NULL;
24510 }
24511
24512
24513 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24514 PyObject *resultobj;
24515 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24516 int result;
24517 PyObject * obj0 = 0 ;
24518 char *kwnames[] = {
24519 (char *) "self", NULL
24520 };
24521
24522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24524 if (SWIG_arg_fail(1)) SWIG_fail;
24525 {
24526 PyThreadState* __tstate = wxPyBeginAllowThreads();
24527 result = (int)(arg1)->GetFlags();
24528
24529 wxPyEndAllowThreads(__tstate);
24530 if (PyErr_Occurred()) SWIG_fail;
24531 }
24532 {
24533 resultobj = SWIG_From_int((int)(result));
24534 }
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24542 PyObject *resultobj;
24543 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24544 int result;
24545 PyObject * obj0 = 0 ;
24546 char *kwnames[] = {
24547 (char *) "self", NULL
24548 };
24549
24550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24552 if (SWIG_arg_fail(1)) SWIG_fail;
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 result = (int)(arg1)->GetKeyCode();
24556
24557 wxPyEndAllowThreads(__tstate);
24558 if (PyErr_Occurred()) SWIG_fail;
24559 }
24560 {
24561 resultobj = SWIG_From_int((int)(result));
24562 }
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj;
24571 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24572 int result;
24573 PyObject * obj0 = 0 ;
24574 char *kwnames[] = {
24575 (char *) "self", NULL
24576 };
24577
24578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24580 if (SWIG_arg_fail(1)) SWIG_fail;
24581 {
24582 PyThreadState* __tstate = wxPyBeginAllowThreads();
24583 result = (int)(arg1)->GetCommand();
24584
24585 wxPyEndAllowThreads(__tstate);
24586 if (PyErr_Occurred()) SWIG_fail;
24587 }
24588 {
24589 resultobj = SWIG_From_int((int)(result));
24590 }
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24598 PyObject *obj;
24599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24600 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24601 Py_INCREF(obj);
24602 return Py_BuildValue((char *)"");
24603 }
24604 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24605 PyObject *resultobj;
24606 int arg1 ;
24607 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24608 wxAcceleratorTable *result;
24609 PyObject * obj0 = 0 ;
24610 char *kwnames[] = {
24611 (char *) "n", NULL
24612 };
24613
24614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24615 {
24616 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24617 if (arg2) arg1 = PyList_Size(obj0);
24618 else arg1 = 0;
24619 }
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24623
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24628 {
24629 delete [] arg2;
24630 }
24631 return resultobj;
24632 fail:
24633 {
24634 delete [] arg2;
24635 }
24636 return NULL;
24637 }
24638
24639
24640 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj;
24642 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24643 PyObject * obj0 = 0 ;
24644 char *kwnames[] = {
24645 (char *) "self", NULL
24646 };
24647
24648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24650 if (SWIG_arg_fail(1)) SWIG_fail;
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 delete arg1;
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 Py_INCREF(Py_None); resultobj = Py_None;
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24666 PyObject *resultobj;
24667 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24668 bool result;
24669 PyObject * obj0 = 0 ;
24670 char *kwnames[] = {
24671 (char *) "self", NULL
24672 };
24673
24674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24676 if (SWIG_arg_fail(1)) SWIG_fail;
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24680
24681 wxPyEndAllowThreads(__tstate);
24682 if (PyErr_Occurred()) SWIG_fail;
24683 }
24684 {
24685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24686 }
24687 return resultobj;
24688 fail:
24689 return NULL;
24690 }
24691
24692
24693 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24694 PyObject *obj;
24695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24696 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24697 Py_INCREF(obj);
24698 return Py_BuildValue((char *)"");
24699 }
24700 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24701 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24702 return 1;
24703 }
24704
24705
24706 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24707 PyObject *pyobj;
24708
24709 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24710 return pyobj;
24711 }
24712
24713
24714 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj;
24716 wxString *arg1 = 0 ;
24717 wxAcceleratorEntry *result;
24718 bool temp1 = false ;
24719 PyObject * obj0 = 0 ;
24720 char *kwnames[] = {
24721 (char *) "label", NULL
24722 };
24723
24724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24725 {
24726 arg1 = wxString_in_helper(obj0);
24727 if (arg1 == NULL) SWIG_fail;
24728 temp1 = true;
24729 }
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24733
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24738 {
24739 if (temp1)
24740 delete arg1;
24741 }
24742 return resultobj;
24743 fail:
24744 {
24745 if (temp1)
24746 delete arg1;
24747 }
24748 return NULL;
24749 }
24750
24751
24752 static int _wrap_PanelNameStr_set(PyObject *) {
24753 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24754 return 1;
24755 }
24756
24757
24758 static PyObject *_wrap_PanelNameStr_get(void) {
24759 PyObject *pyobj;
24760
24761 {
24762 #if wxUSE_UNICODE
24763 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24764 #else
24765 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24766 #endif
24767 }
24768 return pyobj;
24769 }
24770
24771
24772 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24773 PyObject *resultobj;
24774 wxVisualAttributes *result;
24775 char *kwnames[] = {
24776 NULL
24777 };
24778
24779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24780 {
24781 PyThreadState* __tstate = wxPyBeginAllowThreads();
24782 result = (wxVisualAttributes *)new_wxVisualAttributes();
24783
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj;
24796 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24797 PyObject * obj0 = 0 ;
24798 char *kwnames[] = {
24799 (char *) "self", NULL
24800 };
24801
24802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24804 if (SWIG_arg_fail(1)) SWIG_fail;
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 delete_wxVisualAttributes(arg1);
24808
24809 wxPyEndAllowThreads(__tstate);
24810 if (PyErr_Occurred()) SWIG_fail;
24811 }
24812 Py_INCREF(Py_None); resultobj = Py_None;
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24820 PyObject *resultobj;
24821 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24822 wxFont *arg2 = (wxFont *) 0 ;
24823 PyObject * obj0 = 0 ;
24824 PyObject * obj1 = 0 ;
24825 char *kwnames[] = {
24826 (char *) "self",(char *) "font", NULL
24827 };
24828
24829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24831 if (SWIG_arg_fail(1)) SWIG_fail;
24832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24833 if (SWIG_arg_fail(2)) SWIG_fail;
24834 if (arg1) (arg1)->font = *arg2;
24835
24836 Py_INCREF(Py_None); resultobj = Py_None;
24837 return resultobj;
24838 fail:
24839 return NULL;
24840 }
24841
24842
24843 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24844 PyObject *resultobj;
24845 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24846 wxFont *result;
24847 PyObject * obj0 = 0 ;
24848 char *kwnames[] = {
24849 (char *) "self", NULL
24850 };
24851
24852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24854 if (SWIG_arg_fail(1)) SWIG_fail;
24855 result = (wxFont *)& ((arg1)->font);
24856
24857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj;
24866 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24867 wxColour *arg2 = (wxColour *) 0 ;
24868 PyObject * obj0 = 0 ;
24869 PyObject * obj1 = 0 ;
24870 char *kwnames[] = {
24871 (char *) "self",(char *) "colFg", NULL
24872 };
24873
24874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24876 if (SWIG_arg_fail(1)) SWIG_fail;
24877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24878 if (SWIG_arg_fail(2)) SWIG_fail;
24879 if (arg1) (arg1)->colFg = *arg2;
24880
24881 Py_INCREF(Py_None); resultobj = Py_None;
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24889 PyObject *resultobj;
24890 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24891 wxColour *result;
24892 PyObject * obj0 = 0 ;
24893 char *kwnames[] = {
24894 (char *) "self", NULL
24895 };
24896
24897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24899 if (SWIG_arg_fail(1)) SWIG_fail;
24900 result = (wxColour *)& ((arg1)->colFg);
24901
24902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24903 return resultobj;
24904 fail:
24905 return NULL;
24906 }
24907
24908
24909 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24910 PyObject *resultobj;
24911 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24912 wxColour *arg2 = (wxColour *) 0 ;
24913 PyObject * obj0 = 0 ;
24914 PyObject * obj1 = 0 ;
24915 char *kwnames[] = {
24916 (char *) "self",(char *) "colBg", NULL
24917 };
24918
24919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24921 if (SWIG_arg_fail(1)) SWIG_fail;
24922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24923 if (SWIG_arg_fail(2)) SWIG_fail;
24924 if (arg1) (arg1)->colBg = *arg2;
24925
24926 Py_INCREF(Py_None); resultobj = Py_None;
24927 return resultobj;
24928 fail:
24929 return NULL;
24930 }
24931
24932
24933 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24934 PyObject *resultobj;
24935 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24936 wxColour *result;
24937 PyObject * obj0 = 0 ;
24938 char *kwnames[] = {
24939 (char *) "self", NULL
24940 };
24941
24942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24944 if (SWIG_arg_fail(1)) SWIG_fail;
24945 result = (wxColour *)& ((arg1)->colBg);
24946
24947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24955 PyObject *obj;
24956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24957 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24958 Py_INCREF(obj);
24959 return Py_BuildValue((char *)"");
24960 }
24961 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj;
24963 wxWindow *arg1 = (wxWindow *) 0 ;
24964 int arg2 = (int) (int)-1 ;
24965 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24966 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24967 wxSize const &arg4_defvalue = wxDefaultSize ;
24968 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24969 long arg5 = (long) 0 ;
24970 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24971 wxString *arg6 = (wxString *) &arg6_defvalue ;
24972 wxWindow *result;
24973 wxPoint temp3 ;
24974 wxSize temp4 ;
24975 bool temp6 = false ;
24976 PyObject * obj0 = 0 ;
24977 PyObject * obj1 = 0 ;
24978 PyObject * obj2 = 0 ;
24979 PyObject * obj3 = 0 ;
24980 PyObject * obj4 = 0 ;
24981 PyObject * obj5 = 0 ;
24982 char *kwnames[] = {
24983 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24984 };
24985
24986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24988 if (SWIG_arg_fail(1)) SWIG_fail;
24989 if (obj1) {
24990 {
24991 arg2 = (int const)(SWIG_As_int(obj1));
24992 if (SWIG_arg_fail(2)) SWIG_fail;
24993 }
24994 }
24995 if (obj2) {
24996 {
24997 arg3 = &temp3;
24998 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24999 }
25000 }
25001 if (obj3) {
25002 {
25003 arg4 = &temp4;
25004 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25005 }
25006 }
25007 if (obj4) {
25008 {
25009 arg5 = (long)(SWIG_As_long(obj4));
25010 if (SWIG_arg_fail(5)) SWIG_fail;
25011 }
25012 }
25013 if (obj5) {
25014 {
25015 arg6 = wxString_in_helper(obj5);
25016 if (arg6 == NULL) SWIG_fail;
25017 temp6 = true;
25018 }
25019 }
25020 {
25021 if (!wxPyCheckForApp()) SWIG_fail;
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25024
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25029 {
25030 if (temp6)
25031 delete arg6;
25032 }
25033 return resultobj;
25034 fail:
25035 {
25036 if (temp6)
25037 delete arg6;
25038 }
25039 return NULL;
25040 }
25041
25042
25043 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25044 PyObject *resultobj;
25045 wxWindow *result;
25046 char *kwnames[] = {
25047 NULL
25048 };
25049
25050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25051 {
25052 if (!wxPyCheckForApp()) SWIG_fail;
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 result = (wxWindow *)new wxWindow();
25055
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25067 PyObject *resultobj;
25068 wxWindow *arg1 = (wxWindow *) 0 ;
25069 wxWindow *arg2 = (wxWindow *) 0 ;
25070 int arg3 = (int) (int)-1 ;
25071 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25072 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25073 wxSize const &arg5_defvalue = wxDefaultSize ;
25074 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25075 long arg6 = (long) 0 ;
25076 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25077 wxString *arg7 = (wxString *) &arg7_defvalue ;
25078 bool result;
25079 wxPoint temp4 ;
25080 wxSize temp5 ;
25081 bool temp7 = false ;
25082 PyObject * obj0 = 0 ;
25083 PyObject * obj1 = 0 ;
25084 PyObject * obj2 = 0 ;
25085 PyObject * obj3 = 0 ;
25086 PyObject * obj4 = 0 ;
25087 PyObject * obj5 = 0 ;
25088 PyObject * obj6 = 0 ;
25089 char *kwnames[] = {
25090 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25091 };
25092
25093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25095 if (SWIG_arg_fail(1)) SWIG_fail;
25096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25097 if (SWIG_arg_fail(2)) SWIG_fail;
25098 if (obj2) {
25099 {
25100 arg3 = (int const)(SWIG_As_int(obj2));
25101 if (SWIG_arg_fail(3)) SWIG_fail;
25102 }
25103 }
25104 if (obj3) {
25105 {
25106 arg4 = &temp4;
25107 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25108 }
25109 }
25110 if (obj4) {
25111 {
25112 arg5 = &temp5;
25113 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25114 }
25115 }
25116 if (obj5) {
25117 {
25118 arg6 = (long)(SWIG_As_long(obj5));
25119 if (SWIG_arg_fail(6)) SWIG_fail;
25120 }
25121 }
25122 if (obj6) {
25123 {
25124 arg7 = wxString_in_helper(obj6);
25125 if (arg7 == NULL) SWIG_fail;
25126 temp7 = true;
25127 }
25128 }
25129 {
25130 PyThreadState* __tstate = wxPyBeginAllowThreads();
25131 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25132
25133 wxPyEndAllowThreads(__tstate);
25134 if (PyErr_Occurred()) SWIG_fail;
25135 }
25136 {
25137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25138 }
25139 {
25140 if (temp7)
25141 delete arg7;
25142 }
25143 return resultobj;
25144 fail:
25145 {
25146 if (temp7)
25147 delete arg7;
25148 }
25149 return NULL;
25150 }
25151
25152
25153 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj;
25155 wxWindow *arg1 = (wxWindow *) 0 ;
25156 bool arg2 = (bool) false ;
25157 bool result;
25158 PyObject * obj0 = 0 ;
25159 PyObject * obj1 = 0 ;
25160 char *kwnames[] = {
25161 (char *) "self",(char *) "force", NULL
25162 };
25163
25164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25166 if (SWIG_arg_fail(1)) SWIG_fail;
25167 if (obj1) {
25168 {
25169 arg2 = (bool)(SWIG_As_bool(obj1));
25170 if (SWIG_arg_fail(2)) SWIG_fail;
25171 }
25172 }
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 result = (bool)(arg1)->Close(arg2);
25176
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 wxWindow *arg1 = (wxWindow *) 0 ;
25192 bool result;
25193 PyObject * obj0 = 0 ;
25194 char *kwnames[] = {
25195 (char *) "self", NULL
25196 };
25197
25198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25200 if (SWIG_arg_fail(1)) SWIG_fail;
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = (bool)(arg1)->Destroy();
25204
25205 wxPyEndAllowThreads(__tstate);
25206 if (PyErr_Occurred()) SWIG_fail;
25207 }
25208 {
25209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25210 }
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj;
25219 wxWindow *arg1 = (wxWindow *) 0 ;
25220 bool result;
25221 PyObject * obj0 = 0 ;
25222 char *kwnames[] = {
25223 (char *) "self", NULL
25224 };
25225
25226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25228 if (SWIG_arg_fail(1)) SWIG_fail;
25229 {
25230 PyThreadState* __tstate = wxPyBeginAllowThreads();
25231 result = (bool)(arg1)->DestroyChildren();
25232
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 {
25237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25238 }
25239 return resultobj;
25240 fail:
25241 return NULL;
25242 }
25243
25244
25245 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25246 PyObject *resultobj;
25247 wxWindow *arg1 = (wxWindow *) 0 ;
25248 bool result;
25249 PyObject * obj0 = 0 ;
25250 char *kwnames[] = {
25251 (char *) "self", NULL
25252 };
25253
25254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25256 if (SWIG_arg_fail(1)) SWIG_fail;
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25260
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 {
25265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25266 }
25267 return resultobj;
25268 fail:
25269 return NULL;
25270 }
25271
25272
25273 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25274 PyObject *resultobj;
25275 wxWindow *arg1 = (wxWindow *) 0 ;
25276 wxString *arg2 = 0 ;
25277 bool temp2 = false ;
25278 PyObject * obj0 = 0 ;
25279 PyObject * obj1 = 0 ;
25280 char *kwnames[] = {
25281 (char *) "self",(char *) "title", NULL
25282 };
25283
25284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25286 if (SWIG_arg_fail(1)) SWIG_fail;
25287 {
25288 arg2 = wxString_in_helper(obj1);
25289 if (arg2 == NULL) SWIG_fail;
25290 temp2 = true;
25291 }
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 (arg1)->SetTitle((wxString const &)*arg2);
25295
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 Py_INCREF(Py_None); resultobj = Py_None;
25300 {
25301 if (temp2)
25302 delete arg2;
25303 }
25304 return resultobj;
25305 fail:
25306 {
25307 if (temp2)
25308 delete arg2;
25309 }
25310 return NULL;
25311 }
25312
25313
25314 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj;
25316 wxWindow *arg1 = (wxWindow *) 0 ;
25317 wxString result;
25318 PyObject * obj0 = 0 ;
25319 char *kwnames[] = {
25320 (char *) "self", NULL
25321 };
25322
25323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25325 if (SWIG_arg_fail(1)) SWIG_fail;
25326 {
25327 PyThreadState* __tstate = wxPyBeginAllowThreads();
25328 result = ((wxWindow const *)arg1)->GetTitle();
25329
25330 wxPyEndAllowThreads(__tstate);
25331 if (PyErr_Occurred()) SWIG_fail;
25332 }
25333 {
25334 #if wxUSE_UNICODE
25335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25336 #else
25337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25338 #endif
25339 }
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25347 PyObject *resultobj;
25348 wxWindow *arg1 = (wxWindow *) 0 ;
25349 wxString *arg2 = 0 ;
25350 bool temp2 = false ;
25351 PyObject * obj0 = 0 ;
25352 PyObject * obj1 = 0 ;
25353 char *kwnames[] = {
25354 (char *) "self",(char *) "label", NULL
25355 };
25356
25357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25359 if (SWIG_arg_fail(1)) SWIG_fail;
25360 {
25361 arg2 = wxString_in_helper(obj1);
25362 if (arg2 == NULL) SWIG_fail;
25363 temp2 = true;
25364 }
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 (arg1)->SetLabel((wxString const &)*arg2);
25368
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 Py_INCREF(Py_None); resultobj = Py_None;
25373 {
25374 if (temp2)
25375 delete arg2;
25376 }
25377 return resultobj;
25378 fail:
25379 {
25380 if (temp2)
25381 delete arg2;
25382 }
25383 return NULL;
25384 }
25385
25386
25387 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25388 PyObject *resultobj;
25389 wxWindow *arg1 = (wxWindow *) 0 ;
25390 wxString result;
25391 PyObject * obj0 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "self", NULL
25394 };
25395
25396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25398 if (SWIG_arg_fail(1)) SWIG_fail;
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = ((wxWindow const *)arg1)->GetLabel();
25402
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 {
25407 #if wxUSE_UNICODE
25408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25409 #else
25410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25411 #endif
25412 }
25413 return resultobj;
25414 fail:
25415 return NULL;
25416 }
25417
25418
25419 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25420 PyObject *resultobj;
25421 wxWindow *arg1 = (wxWindow *) 0 ;
25422 wxString *arg2 = 0 ;
25423 bool temp2 = false ;
25424 PyObject * obj0 = 0 ;
25425 PyObject * obj1 = 0 ;
25426 char *kwnames[] = {
25427 (char *) "self",(char *) "name", NULL
25428 };
25429
25430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25432 if (SWIG_arg_fail(1)) SWIG_fail;
25433 {
25434 arg2 = wxString_in_helper(obj1);
25435 if (arg2 == NULL) SWIG_fail;
25436 temp2 = true;
25437 }
25438 {
25439 PyThreadState* __tstate = wxPyBeginAllowThreads();
25440 (arg1)->SetName((wxString const &)*arg2);
25441
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 Py_INCREF(Py_None); resultobj = Py_None;
25446 {
25447 if (temp2)
25448 delete arg2;
25449 }
25450 return resultobj;
25451 fail:
25452 {
25453 if (temp2)
25454 delete arg2;
25455 }
25456 return NULL;
25457 }
25458
25459
25460 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj;
25462 wxWindow *arg1 = (wxWindow *) 0 ;
25463 wxString result;
25464 PyObject * obj0 = 0 ;
25465 char *kwnames[] = {
25466 (char *) "self", NULL
25467 };
25468
25469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25471 if (SWIG_arg_fail(1)) SWIG_fail;
25472 {
25473 PyThreadState* __tstate = wxPyBeginAllowThreads();
25474 result = ((wxWindow const *)arg1)->GetName();
25475
25476 wxPyEndAllowThreads(__tstate);
25477 if (PyErr_Occurred()) SWIG_fail;
25478 }
25479 {
25480 #if wxUSE_UNICODE
25481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25482 #else
25483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25484 #endif
25485 }
25486 return resultobj;
25487 fail:
25488 return NULL;
25489 }
25490
25491
25492 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25493 PyObject *resultobj;
25494 wxWindow *arg1 = (wxWindow *) 0 ;
25495 wxWindowVariant arg2 ;
25496 PyObject * obj0 = 0 ;
25497 PyObject * obj1 = 0 ;
25498 char *kwnames[] = {
25499 (char *) "self",(char *) "variant", NULL
25500 };
25501
25502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25504 if (SWIG_arg_fail(1)) SWIG_fail;
25505 {
25506 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25507 if (SWIG_arg_fail(2)) SWIG_fail;
25508 }
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25512
25513 wxPyEndAllowThreads(__tstate);
25514 if (PyErr_Occurred()) SWIG_fail;
25515 }
25516 Py_INCREF(Py_None); resultobj = Py_None;
25517 return resultobj;
25518 fail:
25519 return NULL;
25520 }
25521
25522
25523 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25524 PyObject *resultobj;
25525 wxWindow *arg1 = (wxWindow *) 0 ;
25526 wxWindowVariant result;
25527 PyObject * obj0 = 0 ;
25528 char *kwnames[] = {
25529 (char *) "self", NULL
25530 };
25531
25532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25534 if (SWIG_arg_fail(1)) SWIG_fail;
25535 {
25536 PyThreadState* __tstate = wxPyBeginAllowThreads();
25537 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25538
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 resultobj = SWIG_From_int((result));
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25550 PyObject *resultobj;
25551 wxWindow *arg1 = (wxWindow *) 0 ;
25552 int arg2 ;
25553 PyObject * obj0 = 0 ;
25554 PyObject * obj1 = 0 ;
25555 char *kwnames[] = {
25556 (char *) "self",(char *) "winid", NULL
25557 };
25558
25559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25561 if (SWIG_arg_fail(1)) SWIG_fail;
25562 {
25563 arg2 = (int)(SWIG_As_int(obj1));
25564 if (SWIG_arg_fail(2)) SWIG_fail;
25565 }
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 (arg1)->SetId(arg2);
25569
25570 wxPyEndAllowThreads(__tstate);
25571 if (PyErr_Occurred()) SWIG_fail;
25572 }
25573 Py_INCREF(Py_None); resultobj = Py_None;
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25581 PyObject *resultobj;
25582 wxWindow *arg1 = (wxWindow *) 0 ;
25583 int result;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (int)((wxWindow const *)arg1)->GetId();
25595
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 {
25600 resultobj = SWIG_From_int((int)(result));
25601 }
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25609 PyObject *resultobj;
25610 int result;
25611 char *kwnames[] = {
25612 NULL
25613 };
25614
25615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (int)wxWindow::NewControlId();
25619
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 {
25624 resultobj = SWIG_From_int((int)(result));
25625 }
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25633 PyObject *resultobj;
25634 int arg1 ;
25635 int result;
25636 PyObject * obj0 = 0 ;
25637 char *kwnames[] = {
25638 (char *) "winid", NULL
25639 };
25640
25641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25642 {
25643 arg1 = (int)(SWIG_As_int(obj0));
25644 if (SWIG_arg_fail(1)) SWIG_fail;
25645 }
25646 {
25647 PyThreadState* __tstate = wxPyBeginAllowThreads();
25648 result = (int)wxWindow::NextControlId(arg1);
25649
25650 wxPyEndAllowThreads(__tstate);
25651 if (PyErr_Occurred()) SWIG_fail;
25652 }
25653 {
25654 resultobj = SWIG_From_int((int)(result));
25655 }
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25663 PyObject *resultobj;
25664 int arg1 ;
25665 int result;
25666 PyObject * obj0 = 0 ;
25667 char *kwnames[] = {
25668 (char *) "winid", NULL
25669 };
25670
25671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25672 {
25673 arg1 = (int)(SWIG_As_int(obj0));
25674 if (SWIG_arg_fail(1)) SWIG_fail;
25675 }
25676 {
25677 PyThreadState* __tstate = wxPyBeginAllowThreads();
25678 result = (int)wxWindow::PrevControlId(arg1);
25679
25680 wxPyEndAllowThreads(__tstate);
25681 if (PyErr_Occurred()) SWIG_fail;
25682 }
25683 {
25684 resultobj = SWIG_From_int((int)(result));
25685 }
25686 return resultobj;
25687 fail:
25688 return NULL;
25689 }
25690
25691
25692 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25693 PyObject *resultobj;
25694 wxWindow *arg1 = (wxWindow *) 0 ;
25695 wxSize *arg2 = 0 ;
25696 wxSize temp2 ;
25697 PyObject * obj0 = 0 ;
25698 PyObject * obj1 = 0 ;
25699 char *kwnames[] = {
25700 (char *) "self",(char *) "size", NULL
25701 };
25702
25703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25705 if (SWIG_arg_fail(1)) SWIG_fail;
25706 {
25707 arg2 = &temp2;
25708 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25709 }
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 (arg1)->SetSize((wxSize const &)*arg2);
25713
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 Py_INCREF(Py_None); resultobj = Py_None;
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj;
25726 wxWindow *arg1 = (wxWindow *) 0 ;
25727 int arg2 ;
25728 int arg3 ;
25729 int arg4 ;
25730 int arg5 ;
25731 int arg6 = (int) wxSIZE_AUTO ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 PyObject * obj2 = 0 ;
25735 PyObject * obj3 = 0 ;
25736 PyObject * obj4 = 0 ;
25737 PyObject * obj5 = 0 ;
25738 char *kwnames[] = {
25739 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25740 };
25741
25742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25744 if (SWIG_arg_fail(1)) SWIG_fail;
25745 {
25746 arg2 = (int)(SWIG_As_int(obj1));
25747 if (SWIG_arg_fail(2)) SWIG_fail;
25748 }
25749 {
25750 arg3 = (int)(SWIG_As_int(obj2));
25751 if (SWIG_arg_fail(3)) SWIG_fail;
25752 }
25753 {
25754 arg4 = (int)(SWIG_As_int(obj3));
25755 if (SWIG_arg_fail(4)) SWIG_fail;
25756 }
25757 {
25758 arg5 = (int)(SWIG_As_int(obj4));
25759 if (SWIG_arg_fail(5)) SWIG_fail;
25760 }
25761 if (obj5) {
25762 {
25763 arg6 = (int)(SWIG_As_int(obj5));
25764 if (SWIG_arg_fail(6)) SWIG_fail;
25765 }
25766 }
25767 {
25768 PyThreadState* __tstate = wxPyBeginAllowThreads();
25769 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25770
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 Py_INCREF(Py_None); resultobj = Py_None;
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj;
25783 wxWindow *arg1 = (wxWindow *) 0 ;
25784 wxRect *arg2 = 0 ;
25785 int arg3 = (int) wxSIZE_AUTO ;
25786 wxRect temp2 ;
25787 PyObject * obj0 = 0 ;
25788 PyObject * obj1 = 0 ;
25789 PyObject * obj2 = 0 ;
25790 char *kwnames[] = {
25791 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25792 };
25793
25794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25796 if (SWIG_arg_fail(1)) SWIG_fail;
25797 {
25798 arg2 = &temp2;
25799 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25800 }
25801 if (obj2) {
25802 {
25803 arg3 = (int)(SWIG_As_int(obj2));
25804 if (SWIG_arg_fail(3)) SWIG_fail;
25805 }
25806 }
25807 {
25808 PyThreadState* __tstate = wxPyBeginAllowThreads();
25809 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25810
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 Py_INCREF(Py_None); resultobj = Py_None;
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25822 PyObject *resultobj;
25823 wxWindow *arg1 = (wxWindow *) 0 ;
25824 int arg2 ;
25825 int arg3 ;
25826 PyObject * obj0 = 0 ;
25827 PyObject * obj1 = 0 ;
25828 PyObject * obj2 = 0 ;
25829 char *kwnames[] = {
25830 (char *) "self",(char *) "width",(char *) "height", NULL
25831 };
25832
25833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25835 if (SWIG_arg_fail(1)) SWIG_fail;
25836 {
25837 arg2 = (int)(SWIG_As_int(obj1));
25838 if (SWIG_arg_fail(2)) SWIG_fail;
25839 }
25840 {
25841 arg3 = (int)(SWIG_As_int(obj2));
25842 if (SWIG_arg_fail(3)) SWIG_fail;
25843 }
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 (arg1)->SetSize(arg2,arg3);
25847
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 Py_INCREF(Py_None); resultobj = Py_None;
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj;
25860 wxWindow *arg1 = (wxWindow *) 0 ;
25861 wxPoint *arg2 = 0 ;
25862 int arg3 = (int) wxSIZE_USE_EXISTING ;
25863 wxPoint temp2 ;
25864 PyObject * obj0 = 0 ;
25865 PyObject * obj1 = 0 ;
25866 PyObject * obj2 = 0 ;
25867 char *kwnames[] = {
25868 (char *) "self",(char *) "pt",(char *) "flags", NULL
25869 };
25870
25871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25873 if (SWIG_arg_fail(1)) SWIG_fail;
25874 {
25875 arg2 = &temp2;
25876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25877 }
25878 if (obj2) {
25879 {
25880 arg3 = (int)(SWIG_As_int(obj2));
25881 if (SWIG_arg_fail(3)) SWIG_fail;
25882 }
25883 }
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 (arg1)->Move((wxPoint const &)*arg2,arg3);
25887
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 Py_INCREF(Py_None); resultobj = Py_None;
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25899 PyObject *resultobj;
25900 wxWindow *arg1 = (wxWindow *) 0 ;
25901 int arg2 ;
25902 int arg3 ;
25903 int arg4 = (int) wxSIZE_USE_EXISTING ;
25904 PyObject * obj0 = 0 ;
25905 PyObject * obj1 = 0 ;
25906 PyObject * obj2 = 0 ;
25907 PyObject * obj3 = 0 ;
25908 char *kwnames[] = {
25909 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25910 };
25911
25912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25914 if (SWIG_arg_fail(1)) SWIG_fail;
25915 {
25916 arg2 = (int)(SWIG_As_int(obj1));
25917 if (SWIG_arg_fail(2)) SWIG_fail;
25918 }
25919 {
25920 arg3 = (int)(SWIG_As_int(obj2));
25921 if (SWIG_arg_fail(3)) SWIG_fail;
25922 }
25923 if (obj3) {
25924 {
25925 arg4 = (int)(SWIG_As_int(obj3));
25926 if (SWIG_arg_fail(4)) SWIG_fail;
25927 }
25928 }
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 (arg1)->Move(arg2,arg3,arg4);
25932
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 Py_INCREF(Py_None); resultobj = Py_None;
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25944 PyObject *resultobj;
25945 wxWindow *arg1 = (wxWindow *) 0 ;
25946 wxSize const &arg2_defvalue = wxDefaultSize ;
25947 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25948 wxSize temp2 ;
25949 PyObject * obj0 = 0 ;
25950 PyObject * obj1 = 0 ;
25951 char *kwnames[] = {
25952 (char *) "self",(char *) "size", NULL
25953 };
25954
25955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25957 if (SWIG_arg_fail(1)) SWIG_fail;
25958 if (obj1) {
25959 {
25960 arg2 = &temp2;
25961 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25962 }
25963 }
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 Py_INCREF(Py_None); resultobj = Py_None;
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj;
25980 wxWindow *arg1 = (wxWindow *) 0 ;
25981 PyObject * obj0 = 0 ;
25982 char *kwnames[] = {
25983 (char *) "self", NULL
25984 };
25985
25986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25988 if (SWIG_arg_fail(1)) SWIG_fail;
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 (arg1)->Raise();
25992
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 Py_INCREF(Py_None); resultobj = Py_None;
25997 return resultobj;
25998 fail:
25999 return NULL;
26000 }
26001
26002
26003 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26004 PyObject *resultobj;
26005 wxWindow *arg1 = (wxWindow *) 0 ;
26006 PyObject * obj0 = 0 ;
26007 char *kwnames[] = {
26008 (char *) "self", NULL
26009 };
26010
26011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26013 if (SWIG_arg_fail(1)) SWIG_fail;
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 (arg1)->Lower();
26017
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 Py_INCREF(Py_None); resultobj = Py_None;
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxWindow *arg1 = (wxWindow *) 0 ;
26031 wxSize *arg2 = 0 ;
26032 wxSize temp2 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char *kwnames[] = {
26036 (char *) "self",(char *) "size", NULL
26037 };
26038
26039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26041 if (SWIG_arg_fail(1)) SWIG_fail;
26042 {
26043 arg2 = &temp2;
26044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 (arg1)->SetClientSize((wxSize const &)*arg2);
26049
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 Py_INCREF(Py_None); resultobj = Py_None;
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj;
26062 wxWindow *arg1 = (wxWindow *) 0 ;
26063 int arg2 ;
26064 int arg3 ;
26065 PyObject * obj0 = 0 ;
26066 PyObject * obj1 = 0 ;
26067 PyObject * obj2 = 0 ;
26068 char *kwnames[] = {
26069 (char *) "self",(char *) "width",(char *) "height", NULL
26070 };
26071
26072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26074 if (SWIG_arg_fail(1)) SWIG_fail;
26075 {
26076 arg2 = (int)(SWIG_As_int(obj1));
26077 if (SWIG_arg_fail(2)) SWIG_fail;
26078 }
26079 {
26080 arg3 = (int)(SWIG_As_int(obj2));
26081 if (SWIG_arg_fail(3)) SWIG_fail;
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 (arg1)->SetClientSize(arg2,arg3);
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 Py_INCREF(Py_None); resultobj = Py_None;
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj;
26099 wxWindow *arg1 = (wxWindow *) 0 ;
26100 wxRect *arg2 = 0 ;
26101 wxRect temp2 ;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char *kwnames[] = {
26105 (char *) "self",(char *) "rect", NULL
26106 };
26107
26108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26110 if (SWIG_arg_fail(1)) SWIG_fail;
26111 {
26112 arg2 = &temp2;
26113 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26114 }
26115 {
26116 PyThreadState* __tstate = wxPyBeginAllowThreads();
26117 (arg1)->SetClientSize((wxRect const &)*arg2);
26118
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 Py_INCREF(Py_None); resultobj = Py_None;
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26130 PyObject *resultobj;
26131 wxWindow *arg1 = (wxWindow *) 0 ;
26132 wxPoint result;
26133 PyObject * obj0 = 0 ;
26134 char *kwnames[] = {
26135 (char *) "self", NULL
26136 };
26137
26138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26140 if (SWIG_arg_fail(1)) SWIG_fail;
26141 {
26142 PyThreadState* __tstate = wxPyBeginAllowThreads();
26143 result = (arg1)->GetPosition();
26144
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 {
26149 wxPoint * resultptr;
26150 resultptr = new wxPoint((wxPoint &)(result));
26151 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26152 }
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26160 PyObject *resultobj;
26161 wxWindow *arg1 = (wxWindow *) 0 ;
26162 int *arg2 = (int *) 0 ;
26163 int *arg3 = (int *) 0 ;
26164 int temp2 ;
26165 int res2 = 0 ;
26166 int temp3 ;
26167 int res3 = 0 ;
26168 PyObject * obj0 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self", NULL
26171 };
26172
26173 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26174 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26177 if (SWIG_arg_fail(1)) SWIG_fail;
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 (arg1)->GetPosition(arg2,arg3);
26181
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 Py_INCREF(Py_None); resultobj = Py_None;
26186 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26187 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26188 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26189 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26197 PyObject *resultobj;
26198 wxWindow *arg1 = (wxWindow *) 0 ;
26199 wxSize result;
26200 PyObject * obj0 = 0 ;
26201 char *kwnames[] = {
26202 (char *) "self", NULL
26203 };
26204
26205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26207 if (SWIG_arg_fail(1)) SWIG_fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = ((wxWindow const *)arg1)->GetSize();
26211
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 {
26216 wxSize * resultptr;
26217 resultptr = new wxSize((wxSize &)(result));
26218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26219 }
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26227 PyObject *resultobj;
26228 wxWindow *arg1 = (wxWindow *) 0 ;
26229 int *arg2 = (int *) 0 ;
26230 int *arg3 = (int *) 0 ;
26231 int temp2 ;
26232 int res2 = 0 ;
26233 int temp3 ;
26234 int res3 = 0 ;
26235 PyObject * obj0 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self", NULL
26238 };
26239
26240 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26241 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26244 if (SWIG_arg_fail(1)) SWIG_fail;
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26248
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 Py_INCREF(Py_None); resultobj = Py_None;
26253 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26254 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26255 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26256 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj;
26265 wxWindow *arg1 = (wxWindow *) 0 ;
26266 wxRect result;
26267 PyObject * obj0 = 0 ;
26268 char *kwnames[] = {
26269 (char *) "self", NULL
26270 };
26271
26272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26274 if (SWIG_arg_fail(1)) SWIG_fail;
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 result = ((wxWindow const *)arg1)->GetRect();
26278
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 {
26283 wxRect * resultptr;
26284 resultptr = new wxRect((wxRect &)(result));
26285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26286 }
26287 return resultobj;
26288 fail:
26289 return NULL;
26290 }
26291
26292
26293 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26294 PyObject *resultobj;
26295 wxWindow *arg1 = (wxWindow *) 0 ;
26296 wxSize result;
26297 PyObject * obj0 = 0 ;
26298 char *kwnames[] = {
26299 (char *) "self", NULL
26300 };
26301
26302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26304 if (SWIG_arg_fail(1)) SWIG_fail;
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = ((wxWindow const *)arg1)->GetClientSize();
26308
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 {
26313 wxSize * resultptr;
26314 resultptr = new wxSize((wxSize &)(result));
26315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26316 }
26317 return resultobj;
26318 fail:
26319 return NULL;
26320 }
26321
26322
26323 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj;
26325 wxWindow *arg1 = (wxWindow *) 0 ;
26326 int *arg2 = (int *) 0 ;
26327 int *arg3 = (int *) 0 ;
26328 int temp2 ;
26329 int res2 = 0 ;
26330 int temp3 ;
26331 int res3 = 0 ;
26332 PyObject * obj0 = 0 ;
26333 char *kwnames[] = {
26334 (char *) "self", NULL
26335 };
26336
26337 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26338 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26341 if (SWIG_arg_fail(1)) SWIG_fail;
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26345
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 Py_INCREF(Py_None); resultobj = Py_None;
26350 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26351 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26352 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26353 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26354 return resultobj;
26355 fail:
26356 return NULL;
26357 }
26358
26359
26360 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26361 PyObject *resultobj;
26362 wxWindow *arg1 = (wxWindow *) 0 ;
26363 wxPoint result;
26364 PyObject * obj0 = 0 ;
26365 char *kwnames[] = {
26366 (char *) "self", NULL
26367 };
26368
26369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26371 if (SWIG_arg_fail(1)) SWIG_fail;
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26375
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 {
26380 wxPoint * resultptr;
26381 resultptr = new wxPoint((wxPoint &)(result));
26382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26383 }
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj;
26392 wxWindow *arg1 = (wxWindow *) 0 ;
26393 wxRect result;
26394 PyObject * obj0 = 0 ;
26395 char *kwnames[] = {
26396 (char *) "self", NULL
26397 };
26398
26399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26401 if (SWIG_arg_fail(1)) SWIG_fail;
26402 {
26403 PyThreadState* __tstate = wxPyBeginAllowThreads();
26404 result = ((wxWindow const *)arg1)->GetClientRect();
26405
26406 wxPyEndAllowThreads(__tstate);
26407 if (PyErr_Occurred()) SWIG_fail;
26408 }
26409 {
26410 wxRect * resultptr;
26411 resultptr = new wxRect((wxRect &)(result));
26412 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26413 }
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj;
26422 wxWindow *arg1 = (wxWindow *) 0 ;
26423 wxSize result;
26424 PyObject * obj0 = 0 ;
26425 char *kwnames[] = {
26426 (char *) "self", NULL
26427 };
26428
26429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26431 if (SWIG_arg_fail(1)) SWIG_fail;
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 result = ((wxWindow const *)arg1)->GetBestSize();
26435
26436 wxPyEndAllowThreads(__tstate);
26437 if (PyErr_Occurred()) SWIG_fail;
26438 }
26439 {
26440 wxSize * resultptr;
26441 resultptr = new wxSize((wxSize &)(result));
26442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26443 }
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26451 PyObject *resultobj;
26452 wxWindow *arg1 = (wxWindow *) 0 ;
26453 int *arg2 = (int *) 0 ;
26454 int *arg3 = (int *) 0 ;
26455 int temp2 ;
26456 int res2 = 0 ;
26457 int temp3 ;
26458 int res3 = 0 ;
26459 PyObject * obj0 = 0 ;
26460 char *kwnames[] = {
26461 (char *) "self", NULL
26462 };
26463
26464 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26465 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26468 if (SWIG_arg_fail(1)) SWIG_fail;
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 Py_INCREF(Py_None); resultobj = Py_None;
26477 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26478 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26479 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26480 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj;
26489 wxWindow *arg1 = (wxWindow *) 0 ;
26490 PyObject * obj0 = 0 ;
26491 char *kwnames[] = {
26492 (char *) "self", NULL
26493 };
26494
26495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26497 if (SWIG_arg_fail(1)) SWIG_fail;
26498 {
26499 PyThreadState* __tstate = wxPyBeginAllowThreads();
26500 (arg1)->InvalidateBestSize();
26501
26502 wxPyEndAllowThreads(__tstate);
26503 if (PyErr_Occurred()) SWIG_fail;
26504 }
26505 Py_INCREF(Py_None); resultobj = Py_None;
26506 return resultobj;
26507 fail:
26508 return NULL;
26509 }
26510
26511
26512 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26513 PyObject *resultobj;
26514 wxWindow *arg1 = (wxWindow *) 0 ;
26515 wxSize result;
26516 PyObject * obj0 = 0 ;
26517 char *kwnames[] = {
26518 (char *) "self", NULL
26519 };
26520
26521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26523 if (SWIG_arg_fail(1)) SWIG_fail;
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26527
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 {
26532 wxSize * resultptr;
26533 resultptr = new wxSize((wxSize &)(result));
26534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26535 }
26536 return resultobj;
26537 fail:
26538 return NULL;
26539 }
26540
26541
26542 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26543 PyObject *resultobj;
26544 wxWindow *arg1 = (wxWindow *) 0 ;
26545 wxSize result;
26546 PyObject * obj0 = 0 ;
26547 char *kwnames[] = {
26548 (char *) "self", NULL
26549 };
26550
26551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26553 if (SWIG_arg_fail(1)) SWIG_fail;
26554 {
26555 PyThreadState* __tstate = wxPyBeginAllowThreads();
26556 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26557
26558 wxPyEndAllowThreads(__tstate);
26559 if (PyErr_Occurred()) SWIG_fail;
26560 }
26561 {
26562 wxSize * resultptr;
26563 resultptr = new wxSize((wxSize &)(result));
26564 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26565 }
26566 return resultobj;
26567 fail:
26568 return NULL;
26569 }
26570
26571
26572 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26573 PyObject *resultobj;
26574 wxWindow *arg1 = (wxWindow *) 0 ;
26575 int arg2 = (int) wxBOTH ;
26576 PyObject * obj0 = 0 ;
26577 PyObject * obj1 = 0 ;
26578 char *kwnames[] = {
26579 (char *) "self",(char *) "direction", NULL
26580 };
26581
26582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26584 if (SWIG_arg_fail(1)) SWIG_fail;
26585 if (obj1) {
26586 {
26587 arg2 = (int)(SWIG_As_int(obj1));
26588 if (SWIG_arg_fail(2)) SWIG_fail;
26589 }
26590 }
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 (arg1)->Center(arg2);
26594
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 Py_INCREF(Py_None); resultobj = Py_None;
26599 return resultobj;
26600 fail:
26601 return NULL;
26602 }
26603
26604
26605 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26606 PyObject *resultobj;
26607 wxWindow *arg1 = (wxWindow *) 0 ;
26608 int arg2 = (int) wxBOTH ;
26609 PyObject * obj0 = 0 ;
26610 PyObject * obj1 = 0 ;
26611 char *kwnames[] = {
26612 (char *) "self",(char *) "dir", NULL
26613 };
26614
26615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26617 if (SWIG_arg_fail(1)) SWIG_fail;
26618 if (obj1) {
26619 {
26620 arg2 = (int)(SWIG_As_int(obj1));
26621 if (SWIG_arg_fail(2)) SWIG_fail;
26622 }
26623 }
26624 {
26625 PyThreadState* __tstate = wxPyBeginAllowThreads();
26626 (arg1)->CenterOnScreen(arg2);
26627
26628 wxPyEndAllowThreads(__tstate);
26629 if (PyErr_Occurred()) SWIG_fail;
26630 }
26631 Py_INCREF(Py_None); resultobj = Py_None;
26632 return resultobj;
26633 fail:
26634 return NULL;
26635 }
26636
26637
26638 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26639 PyObject *resultobj;
26640 wxWindow *arg1 = (wxWindow *) 0 ;
26641 int arg2 = (int) wxBOTH ;
26642 PyObject * obj0 = 0 ;
26643 PyObject * obj1 = 0 ;
26644 char *kwnames[] = {
26645 (char *) "self",(char *) "dir", NULL
26646 };
26647
26648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26650 if (SWIG_arg_fail(1)) SWIG_fail;
26651 if (obj1) {
26652 {
26653 arg2 = (int)(SWIG_As_int(obj1));
26654 if (SWIG_arg_fail(2)) SWIG_fail;
26655 }
26656 }
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 (arg1)->CenterOnParent(arg2);
26660
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 Py_INCREF(Py_None); resultobj = Py_None;
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26672 PyObject *resultobj;
26673 wxWindow *arg1 = (wxWindow *) 0 ;
26674 PyObject * obj0 = 0 ;
26675 char *kwnames[] = {
26676 (char *) "self", NULL
26677 };
26678
26679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26681 if (SWIG_arg_fail(1)) SWIG_fail;
26682 {
26683 PyThreadState* __tstate = wxPyBeginAllowThreads();
26684 (arg1)->Fit();
26685
26686 wxPyEndAllowThreads(__tstate);
26687 if (PyErr_Occurred()) SWIG_fail;
26688 }
26689 Py_INCREF(Py_None); resultobj = Py_None;
26690 return resultobj;
26691 fail:
26692 return NULL;
26693 }
26694
26695
26696 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26697 PyObject *resultobj;
26698 wxWindow *arg1 = (wxWindow *) 0 ;
26699 PyObject * obj0 = 0 ;
26700 char *kwnames[] = {
26701 (char *) "self", NULL
26702 };
26703
26704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26706 if (SWIG_arg_fail(1)) SWIG_fail;
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 (arg1)->FitInside();
26710
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 Py_INCREF(Py_None); resultobj = Py_None;
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj;
26723 wxWindow *arg1 = (wxWindow *) 0 ;
26724 int arg2 ;
26725 int arg3 ;
26726 int arg4 = (int) -1 ;
26727 int arg5 = (int) -1 ;
26728 int arg6 = (int) -1 ;
26729 int arg7 = (int) -1 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 PyObject * obj2 = 0 ;
26733 PyObject * obj3 = 0 ;
26734 PyObject * obj4 = 0 ;
26735 PyObject * obj5 = 0 ;
26736 PyObject * obj6 = 0 ;
26737 char *kwnames[] = {
26738 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26739 };
26740
26741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26743 if (SWIG_arg_fail(1)) SWIG_fail;
26744 {
26745 arg2 = (int)(SWIG_As_int(obj1));
26746 if (SWIG_arg_fail(2)) SWIG_fail;
26747 }
26748 {
26749 arg3 = (int)(SWIG_As_int(obj2));
26750 if (SWIG_arg_fail(3)) SWIG_fail;
26751 }
26752 if (obj3) {
26753 {
26754 arg4 = (int)(SWIG_As_int(obj3));
26755 if (SWIG_arg_fail(4)) SWIG_fail;
26756 }
26757 }
26758 if (obj4) {
26759 {
26760 arg5 = (int)(SWIG_As_int(obj4));
26761 if (SWIG_arg_fail(5)) SWIG_fail;
26762 }
26763 }
26764 if (obj5) {
26765 {
26766 arg6 = (int)(SWIG_As_int(obj5));
26767 if (SWIG_arg_fail(6)) SWIG_fail;
26768 }
26769 }
26770 if (obj6) {
26771 {
26772 arg7 = (int)(SWIG_As_int(obj6));
26773 if (SWIG_arg_fail(7)) SWIG_fail;
26774 }
26775 }
26776 {
26777 PyThreadState* __tstate = wxPyBeginAllowThreads();
26778 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26779
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 Py_INCREF(Py_None); resultobj = Py_None;
26784 return resultobj;
26785 fail:
26786 return NULL;
26787 }
26788
26789
26790 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26791 PyObject *resultobj;
26792 wxWindow *arg1 = (wxWindow *) 0 ;
26793 wxSize *arg2 = 0 ;
26794 wxSize const &arg3_defvalue = wxDefaultSize ;
26795 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26796 wxSize const &arg4_defvalue = wxDefaultSize ;
26797 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26798 wxSize temp2 ;
26799 wxSize temp3 ;
26800 wxSize temp4 ;
26801 PyObject * obj0 = 0 ;
26802 PyObject * obj1 = 0 ;
26803 PyObject * obj2 = 0 ;
26804 PyObject * obj3 = 0 ;
26805 char *kwnames[] = {
26806 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26807 };
26808
26809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26811 if (SWIG_arg_fail(1)) SWIG_fail;
26812 {
26813 arg2 = &temp2;
26814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26815 }
26816 if (obj2) {
26817 {
26818 arg3 = &temp3;
26819 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26820 }
26821 }
26822 if (obj3) {
26823 {
26824 arg4 = &temp4;
26825 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26826 }
26827 }
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26831
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 Py_INCREF(Py_None); resultobj = Py_None;
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26843 PyObject *resultobj;
26844 wxWindow *arg1 = (wxWindow *) 0 ;
26845 int arg2 ;
26846 int arg3 ;
26847 int arg4 = (int) -1 ;
26848 int arg5 = (int) -1 ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 PyObject * obj2 = 0 ;
26852 PyObject * obj3 = 0 ;
26853 PyObject * obj4 = 0 ;
26854 char *kwnames[] = {
26855 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26856 };
26857
26858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26860 if (SWIG_arg_fail(1)) SWIG_fail;
26861 {
26862 arg2 = (int)(SWIG_As_int(obj1));
26863 if (SWIG_arg_fail(2)) SWIG_fail;
26864 }
26865 {
26866 arg3 = (int)(SWIG_As_int(obj2));
26867 if (SWIG_arg_fail(3)) SWIG_fail;
26868 }
26869 if (obj3) {
26870 {
26871 arg4 = (int)(SWIG_As_int(obj3));
26872 if (SWIG_arg_fail(4)) SWIG_fail;
26873 }
26874 }
26875 if (obj4) {
26876 {
26877 arg5 = (int)(SWIG_As_int(obj4));
26878 if (SWIG_arg_fail(5)) SWIG_fail;
26879 }
26880 }
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26884
26885 wxPyEndAllowThreads(__tstate);
26886 if (PyErr_Occurred()) SWIG_fail;
26887 }
26888 Py_INCREF(Py_None); resultobj = Py_None;
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj;
26897 wxWindow *arg1 = (wxWindow *) 0 ;
26898 wxSize *arg2 = 0 ;
26899 wxSize const &arg3_defvalue = wxDefaultSize ;
26900 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26901 wxSize temp2 ;
26902 wxSize temp3 ;
26903 PyObject * obj0 = 0 ;
26904 PyObject * obj1 = 0 ;
26905 PyObject * obj2 = 0 ;
26906 char *kwnames[] = {
26907 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26908 };
26909
26910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26912 if (SWIG_arg_fail(1)) SWIG_fail;
26913 {
26914 arg2 = &temp2;
26915 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26916 }
26917 if (obj2) {
26918 {
26919 arg3 = &temp3;
26920 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26921 }
26922 }
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26926
26927 wxPyEndAllowThreads(__tstate);
26928 if (PyErr_Occurred()) SWIG_fail;
26929 }
26930 Py_INCREF(Py_None); resultobj = Py_None;
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj;
26939 wxWindow *arg1 = (wxWindow *) 0 ;
26940 wxSize result;
26941 PyObject * obj0 = 0 ;
26942 char *kwnames[] = {
26943 (char *) "self", NULL
26944 };
26945
26946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26948 if (SWIG_arg_fail(1)) SWIG_fail;
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = ((wxWindow const *)arg1)->GetMaxSize();
26952
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 {
26957 wxSize * resultptr;
26958 resultptr = new wxSize((wxSize &)(result));
26959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26960 }
26961 return resultobj;
26962 fail:
26963 return NULL;
26964 }
26965
26966
26967 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26968 PyObject *resultobj;
26969 wxWindow *arg1 = (wxWindow *) 0 ;
26970 wxSize result;
26971 PyObject * obj0 = 0 ;
26972 char *kwnames[] = {
26973 (char *) "self", NULL
26974 };
26975
26976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26978 if (SWIG_arg_fail(1)) SWIG_fail;
26979 {
26980 PyThreadState* __tstate = wxPyBeginAllowThreads();
26981 result = ((wxWindow const *)arg1)->GetMinSize();
26982
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 {
26987 wxSize * resultptr;
26988 resultptr = new wxSize((wxSize &)(result));
26989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26990 }
26991 return resultobj;
26992 fail:
26993 return NULL;
26994 }
26995
26996
26997 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26998 PyObject *resultobj;
26999 wxWindow *arg1 = (wxWindow *) 0 ;
27000 wxSize *arg2 = 0 ;
27001 wxSize temp2 ;
27002 PyObject * obj0 = 0 ;
27003 PyObject * obj1 = 0 ;
27004 char *kwnames[] = {
27005 (char *) "self",(char *) "minSize", NULL
27006 };
27007
27008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27010 if (SWIG_arg_fail(1)) SWIG_fail;
27011 {
27012 arg2 = &temp2;
27013 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27014 }
27015 {
27016 PyThreadState* __tstate = wxPyBeginAllowThreads();
27017 (arg1)->SetMinSize((wxSize const &)*arg2);
27018
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 Py_INCREF(Py_None); resultobj = Py_None;
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27030 PyObject *resultobj;
27031 wxWindow *arg1 = (wxWindow *) 0 ;
27032 wxSize *arg2 = 0 ;
27033 wxSize temp2 ;
27034 PyObject * obj0 = 0 ;
27035 PyObject * obj1 = 0 ;
27036 char *kwnames[] = {
27037 (char *) "self",(char *) "maxSize", NULL
27038 };
27039
27040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27042 if (SWIG_arg_fail(1)) SWIG_fail;
27043 {
27044 arg2 = &temp2;
27045 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27046 }
27047 {
27048 PyThreadState* __tstate = wxPyBeginAllowThreads();
27049 (arg1)->SetMaxSize((wxSize const &)*arg2);
27050
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 Py_INCREF(Py_None); resultobj = Py_None;
27055 return resultobj;
27056 fail:
27057 return NULL;
27058 }
27059
27060
27061 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27062 PyObject *resultobj;
27063 wxWindow *arg1 = (wxWindow *) 0 ;
27064 int result;
27065 PyObject * obj0 = 0 ;
27066 char *kwnames[] = {
27067 (char *) "self", NULL
27068 };
27069
27070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27072 if (SWIG_arg_fail(1)) SWIG_fail;
27073 {
27074 PyThreadState* __tstate = wxPyBeginAllowThreads();
27075 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27076
27077 wxPyEndAllowThreads(__tstate);
27078 if (PyErr_Occurred()) SWIG_fail;
27079 }
27080 {
27081 resultobj = SWIG_From_int((int)(result));
27082 }
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27090 PyObject *resultobj;
27091 wxWindow *arg1 = (wxWindow *) 0 ;
27092 int result;
27093 PyObject * obj0 = 0 ;
27094 char *kwnames[] = {
27095 (char *) "self", NULL
27096 };
27097
27098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27100 if (SWIG_arg_fail(1)) SWIG_fail;
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27104
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 {
27109 resultobj = SWIG_From_int((int)(result));
27110 }
27111 return resultobj;
27112 fail:
27113 return NULL;
27114 }
27115
27116
27117 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27118 PyObject *resultobj;
27119 wxWindow *arg1 = (wxWindow *) 0 ;
27120 int result;
27121 PyObject * obj0 = 0 ;
27122 char *kwnames[] = {
27123 (char *) "self", NULL
27124 };
27125
27126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27128 if (SWIG_arg_fail(1)) SWIG_fail;
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27132
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 {
27137 resultobj = SWIG_From_int((int)(result));
27138 }
27139 return resultobj;
27140 fail:
27141 return NULL;
27142 }
27143
27144
27145 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj;
27147 wxWindow *arg1 = (wxWindow *) 0 ;
27148 int result;
27149 PyObject * obj0 = 0 ;
27150 char *kwnames[] = {
27151 (char *) "self", NULL
27152 };
27153
27154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(1)) SWIG_fail;
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 {
27165 resultobj = SWIG_From_int((int)(result));
27166 }
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27174 PyObject *resultobj;
27175 wxWindow *arg1 = (wxWindow *) 0 ;
27176 wxSize *arg2 = 0 ;
27177 wxSize temp2 ;
27178 PyObject * obj0 = 0 ;
27179 PyObject * obj1 = 0 ;
27180 char *kwnames[] = {
27181 (char *) "self",(char *) "size", NULL
27182 };
27183
27184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27186 if (SWIG_arg_fail(1)) SWIG_fail;
27187 {
27188 arg2 = &temp2;
27189 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27190 }
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27194
27195 wxPyEndAllowThreads(__tstate);
27196 if (PyErr_Occurred()) SWIG_fail;
27197 }
27198 Py_INCREF(Py_None); resultobj = Py_None;
27199 return resultobj;
27200 fail:
27201 return NULL;
27202 }
27203
27204
27205 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27206 PyObject *resultobj;
27207 wxWindow *arg1 = (wxWindow *) 0 ;
27208 int arg2 ;
27209 int arg3 ;
27210 PyObject * obj0 = 0 ;
27211 PyObject * obj1 = 0 ;
27212 PyObject * obj2 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "self",(char *) "w",(char *) "h", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 {
27221 arg2 = (int)(SWIG_As_int(obj1));
27222 if (SWIG_arg_fail(2)) SWIG_fail;
27223 }
27224 {
27225 arg3 = (int)(SWIG_As_int(obj2));
27226 if (SWIG_arg_fail(3)) SWIG_fail;
27227 }
27228 {
27229 PyThreadState* __tstate = wxPyBeginAllowThreads();
27230 (arg1)->SetVirtualSize(arg2,arg3);
27231
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 Py_INCREF(Py_None); resultobj = Py_None;
27236 return resultobj;
27237 fail:
27238 return NULL;
27239 }
27240
27241
27242 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27243 PyObject *resultobj;
27244 wxWindow *arg1 = (wxWindow *) 0 ;
27245 wxSize result;
27246 PyObject * obj0 = 0 ;
27247 char *kwnames[] = {
27248 (char *) "self", NULL
27249 };
27250
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27253 if (SWIG_arg_fail(1)) SWIG_fail;
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 result = ((wxWindow const *)arg1)->GetVirtualSize();
27257
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 {
27262 wxSize * resultptr;
27263 resultptr = new wxSize((wxSize &)(result));
27264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27265 }
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27273 PyObject *resultobj;
27274 wxWindow *arg1 = (wxWindow *) 0 ;
27275 int *arg2 = (int *) 0 ;
27276 int *arg3 = (int *) 0 ;
27277 int temp2 ;
27278 int res2 = 0 ;
27279 int temp3 ;
27280 int res3 = 0 ;
27281 PyObject * obj0 = 0 ;
27282 char *kwnames[] = {
27283 (char *) "self", NULL
27284 };
27285
27286 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27287 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27290 if (SWIG_arg_fail(1)) SWIG_fail;
27291 {
27292 PyThreadState* __tstate = wxPyBeginAllowThreads();
27293 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27294
27295 wxPyEndAllowThreads(__tstate);
27296 if (PyErr_Occurred()) SWIG_fail;
27297 }
27298 Py_INCREF(Py_None); resultobj = Py_None;
27299 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27300 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27301 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27302 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 wxSize result;
27313 PyObject * obj0 = 0 ;
27314 char *kwnames[] = {
27315 (char *) "self", NULL
27316 };
27317
27318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27320 if (SWIG_arg_fail(1)) SWIG_fail;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 {
27329 wxSize * resultptr;
27330 resultptr = new wxSize((wxSize &)(result));
27331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27332 }
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxWindow *arg1 = (wxWindow *) 0 ;
27342 bool arg2 = (bool) true ;
27343 bool result;
27344 PyObject * obj0 = 0 ;
27345 PyObject * obj1 = 0 ;
27346 char *kwnames[] = {
27347 (char *) "self",(char *) "show", NULL
27348 };
27349
27350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27352 if (SWIG_arg_fail(1)) SWIG_fail;
27353 if (obj1) {
27354 {
27355 arg2 = (bool)(SWIG_As_bool(obj1));
27356 if (SWIG_arg_fail(2)) SWIG_fail;
27357 }
27358 }
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = (bool)(arg1)->Show(arg2);
27362
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 {
27367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27368 }
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj;
27377 wxWindow *arg1 = (wxWindow *) 0 ;
27378 bool result;
27379 PyObject * obj0 = 0 ;
27380 char *kwnames[] = {
27381 (char *) "self", NULL
27382 };
27383
27384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27386 if (SWIG_arg_fail(1)) SWIG_fail;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (bool)(arg1)->Hide();
27390
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 {
27395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27396 }
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27404 PyObject *resultobj;
27405 wxWindow *arg1 = (wxWindow *) 0 ;
27406 bool arg2 = (bool) true ;
27407 bool result;
27408 PyObject * obj0 = 0 ;
27409 PyObject * obj1 = 0 ;
27410 char *kwnames[] = {
27411 (char *) "self",(char *) "enable", NULL
27412 };
27413
27414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27416 if (SWIG_arg_fail(1)) SWIG_fail;
27417 if (obj1) {
27418 {
27419 arg2 = (bool)(SWIG_As_bool(obj1));
27420 if (SWIG_arg_fail(2)) SWIG_fail;
27421 }
27422 }
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 result = (bool)(arg1)->Enable(arg2);
27426
27427 wxPyEndAllowThreads(__tstate);
27428 if (PyErr_Occurred()) SWIG_fail;
27429 }
27430 {
27431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27432 }
27433 return resultobj;
27434 fail:
27435 return NULL;
27436 }
27437
27438
27439 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27440 PyObject *resultobj;
27441 wxWindow *arg1 = (wxWindow *) 0 ;
27442 bool result;
27443 PyObject * obj0 = 0 ;
27444 char *kwnames[] = {
27445 (char *) "self", NULL
27446 };
27447
27448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27450 if (SWIG_arg_fail(1)) SWIG_fail;
27451 {
27452 PyThreadState* __tstate = wxPyBeginAllowThreads();
27453 result = (bool)(arg1)->Disable();
27454
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 {
27459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27460 }
27461 return resultobj;
27462 fail:
27463 return NULL;
27464 }
27465
27466
27467 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27468 PyObject *resultobj;
27469 wxWindow *arg1 = (wxWindow *) 0 ;
27470 bool result;
27471 PyObject * obj0 = 0 ;
27472 char *kwnames[] = {
27473 (char *) "self", NULL
27474 };
27475
27476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27478 if (SWIG_arg_fail(1)) SWIG_fail;
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 result = (bool)((wxWindow const *)arg1)->IsShown();
27482
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 {
27487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27488 }
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj;
27497 wxWindow *arg1 = (wxWindow *) 0 ;
27498 bool result;
27499 PyObject * obj0 = 0 ;
27500 char *kwnames[] = {
27501 (char *) "self", NULL
27502 };
27503
27504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27506 if (SWIG_arg_fail(1)) SWIG_fail;
27507 {
27508 PyThreadState* __tstate = wxPyBeginAllowThreads();
27509 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27510
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 {
27515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27516 }
27517 return resultobj;
27518 fail:
27519 return NULL;
27520 }
27521
27522
27523 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27524 PyObject *resultobj;
27525 wxWindow *arg1 = (wxWindow *) 0 ;
27526 long arg2 ;
27527 PyObject * obj0 = 0 ;
27528 PyObject * obj1 = 0 ;
27529 char *kwnames[] = {
27530 (char *) "self",(char *) "style", NULL
27531 };
27532
27533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27535 if (SWIG_arg_fail(1)) SWIG_fail;
27536 {
27537 arg2 = (long)(SWIG_As_long(obj1));
27538 if (SWIG_arg_fail(2)) SWIG_fail;
27539 }
27540 {
27541 PyThreadState* __tstate = wxPyBeginAllowThreads();
27542 (arg1)->SetWindowStyleFlag(arg2);
27543
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 Py_INCREF(Py_None); resultobj = Py_None;
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj;
27556 wxWindow *arg1 = (wxWindow *) 0 ;
27557 long result;
27558 PyObject * obj0 = 0 ;
27559 char *kwnames[] = {
27560 (char *) "self", NULL
27561 };
27562
27563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27565 if (SWIG_arg_fail(1)) SWIG_fail;
27566 {
27567 PyThreadState* __tstate = wxPyBeginAllowThreads();
27568 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27569
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 {
27574 resultobj = SWIG_From_long((long)(result));
27575 }
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27583 PyObject *resultobj;
27584 wxWindow *arg1 = (wxWindow *) 0 ;
27585 int arg2 ;
27586 bool result;
27587 PyObject * obj0 = 0 ;
27588 PyObject * obj1 = 0 ;
27589 char *kwnames[] = {
27590 (char *) "self",(char *) "flag", NULL
27591 };
27592
27593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27595 if (SWIG_arg_fail(1)) SWIG_fail;
27596 {
27597 arg2 = (int)(SWIG_As_int(obj1));
27598 if (SWIG_arg_fail(2)) SWIG_fail;
27599 }
27600 {
27601 PyThreadState* __tstate = wxPyBeginAllowThreads();
27602 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27603
27604 wxPyEndAllowThreads(__tstate);
27605 if (PyErr_Occurred()) SWIG_fail;
27606 }
27607 {
27608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27609 }
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27617 PyObject *resultobj;
27618 wxWindow *arg1 = (wxWindow *) 0 ;
27619 bool result;
27620 PyObject * obj0 = 0 ;
27621 char *kwnames[] = {
27622 (char *) "self", NULL
27623 };
27624
27625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(1)) SWIG_fail;
27628 {
27629 PyThreadState* __tstate = wxPyBeginAllowThreads();
27630 result = (bool)((wxWindow const *)arg1)->IsRetained();
27631
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 {
27636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27637 }
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27645 PyObject *resultobj;
27646 wxWindow *arg1 = (wxWindow *) 0 ;
27647 long arg2 ;
27648 PyObject * obj0 = 0 ;
27649 PyObject * obj1 = 0 ;
27650 char *kwnames[] = {
27651 (char *) "self",(char *) "exStyle", NULL
27652 };
27653
27654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27656 if (SWIG_arg_fail(1)) SWIG_fail;
27657 {
27658 arg2 = (long)(SWIG_As_long(obj1));
27659 if (SWIG_arg_fail(2)) SWIG_fail;
27660 }
27661 {
27662 PyThreadState* __tstate = wxPyBeginAllowThreads();
27663 (arg1)->SetExtraStyle(arg2);
27664
27665 wxPyEndAllowThreads(__tstate);
27666 if (PyErr_Occurred()) SWIG_fail;
27667 }
27668 Py_INCREF(Py_None); resultobj = Py_None;
27669 return resultobj;
27670 fail:
27671 return NULL;
27672 }
27673
27674
27675 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27676 PyObject *resultobj;
27677 wxWindow *arg1 = (wxWindow *) 0 ;
27678 long result;
27679 PyObject * obj0 = 0 ;
27680 char *kwnames[] = {
27681 (char *) "self", NULL
27682 };
27683
27684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27686 if (SWIG_arg_fail(1)) SWIG_fail;
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27690
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 {
27695 resultobj = SWIG_From_long((long)(result));
27696 }
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj;
27705 wxWindow *arg1 = (wxWindow *) 0 ;
27706 bool arg2 = (bool) true ;
27707 PyObject * obj0 = 0 ;
27708 PyObject * obj1 = 0 ;
27709 char *kwnames[] = {
27710 (char *) "self",(char *) "modal", NULL
27711 };
27712
27713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27715 if (SWIG_arg_fail(1)) SWIG_fail;
27716 if (obj1) {
27717 {
27718 arg2 = (bool)(SWIG_As_bool(obj1));
27719 if (SWIG_arg_fail(2)) SWIG_fail;
27720 }
27721 }
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 (arg1)->MakeModal(arg2);
27725
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 Py_INCREF(Py_None); resultobj = Py_None;
27730 return resultobj;
27731 fail:
27732 return NULL;
27733 }
27734
27735
27736 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27737 PyObject *resultobj;
27738 wxWindow *arg1 = (wxWindow *) 0 ;
27739 bool arg2 ;
27740 PyObject * obj0 = 0 ;
27741 PyObject * obj1 = 0 ;
27742 char *kwnames[] = {
27743 (char *) "self",(char *) "enableTheme", NULL
27744 };
27745
27746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27748 if (SWIG_arg_fail(1)) SWIG_fail;
27749 {
27750 arg2 = (bool)(SWIG_As_bool(obj1));
27751 if (SWIG_arg_fail(2)) SWIG_fail;
27752 }
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 (arg1)->SetThemeEnabled(arg2);
27756
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 Py_INCREF(Py_None); resultobj = Py_None;
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27768 PyObject *resultobj;
27769 wxWindow *arg1 = (wxWindow *) 0 ;
27770 bool result;
27771 PyObject * obj0 = 0 ;
27772 char *kwnames[] = {
27773 (char *) "self", NULL
27774 };
27775
27776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27778 if (SWIG_arg_fail(1)) SWIG_fail;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 {
27787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27788 }
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27796 PyObject *resultobj;
27797 wxWindow *arg1 = (wxWindow *) 0 ;
27798 PyObject * obj0 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 (arg1)->SetFocus();
27809
27810 wxPyEndAllowThreads(__tstate);
27811 if (PyErr_Occurred()) SWIG_fail;
27812 }
27813 Py_INCREF(Py_None); resultobj = Py_None;
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27821 PyObject *resultobj;
27822 wxWindow *arg1 = (wxWindow *) 0 ;
27823 PyObject * obj0 = 0 ;
27824 char *kwnames[] = {
27825 (char *) "self", NULL
27826 };
27827
27828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(1)) SWIG_fail;
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 (arg1)->SetFocusFromKbd();
27834
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 Py_INCREF(Py_None); resultobj = Py_None;
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27846 PyObject *resultobj;
27847 wxWindow *result;
27848 char *kwnames[] = {
27849 NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27853 {
27854 if (!wxPyCheckForApp()) SWIG_fail;
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 result = (wxWindow *)wxWindow::FindFocus();
27857
27858 wxPyEndAllowThreads(__tstate);
27859 if (PyErr_Occurred()) SWIG_fail;
27860 }
27861 {
27862 resultobj = wxPyMake_wxObject(result, 0);
27863 }
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27871 PyObject *resultobj;
27872 wxWindow *arg1 = (wxWindow *) 0 ;
27873 bool result;
27874 PyObject * obj0 = 0 ;
27875 char *kwnames[] = {
27876 (char *) "self", NULL
27877 };
27878
27879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27881 if (SWIG_arg_fail(1)) SWIG_fail;
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27885
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 {
27890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27891 }
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj;
27900 wxWindow *arg1 = (wxWindow *) 0 ;
27901 bool result;
27902 PyObject * obj0 = 0 ;
27903 char *kwnames[] = {
27904 (char *) "self", NULL
27905 };
27906
27907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27909 if (SWIG_arg_fail(1)) SWIG_fail;
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27913
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 {
27918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27919 }
27920 return resultobj;
27921 fail:
27922 return NULL;
27923 }
27924
27925
27926 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj;
27928 wxWindow *arg1 = (wxWindow *) 0 ;
27929 wxWindow *result;
27930 PyObject * obj0 = 0 ;
27931 char *kwnames[] = {
27932 (char *) "self", NULL
27933 };
27934
27935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27937 if (SWIG_arg_fail(1)) SWIG_fail;
27938 {
27939 PyThreadState* __tstate = wxPyBeginAllowThreads();
27940 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27941
27942 wxPyEndAllowThreads(__tstate);
27943 if (PyErr_Occurred()) SWIG_fail;
27944 }
27945 {
27946 resultobj = wxPyMake_wxObject(result, 0);
27947 }
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj;
27956 wxWindow *arg1 = (wxWindow *) 0 ;
27957 wxWindow *arg2 = (wxWindow *) 0 ;
27958 wxWindow *result;
27959 PyObject * obj0 = 0 ;
27960 PyObject * obj1 = 0 ;
27961 char *kwnames[] = {
27962 (char *) "self",(char *) "child", NULL
27963 };
27964
27965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27967 if (SWIG_arg_fail(1)) SWIG_fail;
27968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(2)) SWIG_fail;
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27973
27974 wxPyEndAllowThreads(__tstate);
27975 if (PyErr_Occurred()) SWIG_fail;
27976 }
27977 {
27978 resultobj = wxPyMake_wxObject(result, 0);
27979 }
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj;
27988 wxWindow *arg1 = (wxWindow *) 0 ;
27989 wxWindow *arg2 = (wxWindow *) 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char *kwnames[] = {
27993 (char *) "self",(char *) "win", NULL
27994 };
27995
27996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27998 if (SWIG_arg_fail(1)) SWIG_fail;
27999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(2)) SWIG_fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 (arg1)->SetTmpDefaultItem(arg2);
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 Py_INCREF(Py_None); resultobj = Py_None;
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28016 PyObject *resultobj;
28017 wxWindow *arg1 = (wxWindow *) 0 ;
28018 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28019 bool result;
28020 PyObject * obj0 = 0 ;
28021 PyObject * obj1 = 0 ;
28022 char *kwnames[] = {
28023 (char *) "self",(char *) "flags", NULL
28024 };
28025
28026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28028 if (SWIG_arg_fail(1)) SWIG_fail;
28029 if (obj1) {
28030 {
28031 arg2 = (int)(SWIG_As_int(obj1));
28032 if (SWIG_arg_fail(2)) SWIG_fail;
28033 }
28034 }
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 result = (bool)(arg1)->Navigate(arg2);
28038
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 {
28043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28044 }
28045 return resultobj;
28046 fail:
28047 return NULL;
28048 }
28049
28050
28051 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj;
28053 wxWindow *arg1 = (wxWindow *) 0 ;
28054 wxWindow *arg2 = (wxWindow *) 0 ;
28055 PyObject * obj0 = 0 ;
28056 PyObject * obj1 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "self",(char *) "win", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(1)) SWIG_fail;
28064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(2)) SWIG_fail;
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 (arg1)->MoveAfterInTabOrder(arg2);
28069
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 Py_INCREF(Py_None); resultobj = Py_None;
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj;
28082 wxWindow *arg1 = (wxWindow *) 0 ;
28083 wxWindow *arg2 = (wxWindow *) 0 ;
28084 PyObject * obj0 = 0 ;
28085 PyObject * obj1 = 0 ;
28086 char *kwnames[] = {
28087 (char *) "self",(char *) "win", NULL
28088 };
28089
28090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28092 if (SWIG_arg_fail(1)) SWIG_fail;
28093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28094 if (SWIG_arg_fail(2)) SWIG_fail;
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 (arg1)->MoveBeforeInTabOrder(arg2);
28098
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 Py_INCREF(Py_None); resultobj = Py_None;
28103 return resultobj;
28104 fail:
28105 return NULL;
28106 }
28107
28108
28109 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28110 PyObject *resultobj;
28111 wxWindow *arg1 = (wxWindow *) 0 ;
28112 PyObject *result;
28113 PyObject * obj0 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (PyObject *)wxWindow_GetChildren(arg1);
28124
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = result;
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj;
28137 wxWindow *arg1 = (wxWindow *) 0 ;
28138 wxWindow *result;
28139 PyObject * obj0 = 0 ;
28140 char *kwnames[] = {
28141 (char *) "self", NULL
28142 };
28143
28144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28146 if (SWIG_arg_fail(1)) SWIG_fail;
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28150
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 {
28155 resultobj = wxPyMake_wxObject(result, 0);
28156 }
28157 return resultobj;
28158 fail:
28159 return NULL;
28160 }
28161
28162
28163 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28164 PyObject *resultobj;
28165 wxWindow *arg1 = (wxWindow *) 0 ;
28166 wxWindow *result;
28167 PyObject * obj0 = 0 ;
28168 char *kwnames[] = {
28169 (char *) "self", NULL
28170 };
28171
28172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28174 if (SWIG_arg_fail(1)) SWIG_fail;
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28178
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 {
28183 resultobj = wxPyMake_wxObject(result, 0);
28184 }
28185 return resultobj;
28186 fail:
28187 return NULL;
28188 }
28189
28190
28191 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28192 PyObject *resultobj;
28193 wxWindow *arg1 = (wxWindow *) 0 ;
28194 bool result;
28195 PyObject * obj0 = 0 ;
28196 char *kwnames[] = {
28197 (char *) "self", NULL
28198 };
28199
28200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28202 if (SWIG_arg_fail(1)) SWIG_fail;
28203 {
28204 PyThreadState* __tstate = wxPyBeginAllowThreads();
28205 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28206
28207 wxPyEndAllowThreads(__tstate);
28208 if (PyErr_Occurred()) SWIG_fail;
28209 }
28210 {
28211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28212 }
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj;
28221 wxWindow *arg1 = (wxWindow *) 0 ;
28222 wxWindow *arg2 = (wxWindow *) 0 ;
28223 bool result;
28224 PyObject * obj0 = 0 ;
28225 PyObject * obj1 = 0 ;
28226 char *kwnames[] = {
28227 (char *) "self",(char *) "newParent", NULL
28228 };
28229
28230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28232 if (SWIG_arg_fail(1)) SWIG_fail;
28233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28234 if (SWIG_arg_fail(2)) SWIG_fail;
28235 {
28236 PyThreadState* __tstate = wxPyBeginAllowThreads();
28237 result = (bool)(arg1)->Reparent(arg2);
28238
28239 wxPyEndAllowThreads(__tstate);
28240 if (PyErr_Occurred()) SWIG_fail;
28241 }
28242 {
28243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28244 }
28245 return resultobj;
28246 fail:
28247 return NULL;
28248 }
28249
28250
28251 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28252 PyObject *resultobj;
28253 wxWindow *arg1 = (wxWindow *) 0 ;
28254 wxWindow *arg2 = (wxWindow *) 0 ;
28255 PyObject * obj0 = 0 ;
28256 PyObject * obj1 = 0 ;
28257 char *kwnames[] = {
28258 (char *) "self",(char *) "child", NULL
28259 };
28260
28261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28263 if (SWIG_arg_fail(1)) SWIG_fail;
28264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28265 if (SWIG_arg_fail(2)) SWIG_fail;
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 (arg1)->AddChild(arg2);
28269
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 Py_INCREF(Py_None); resultobj = Py_None;
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28281 PyObject *resultobj;
28282 wxWindow *arg1 = (wxWindow *) 0 ;
28283 wxWindow *arg2 = (wxWindow *) 0 ;
28284 PyObject * obj0 = 0 ;
28285 PyObject * obj1 = 0 ;
28286 char *kwnames[] = {
28287 (char *) "self",(char *) "child", NULL
28288 };
28289
28290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28292 if (SWIG_arg_fail(1)) SWIG_fail;
28293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28294 if (SWIG_arg_fail(2)) SWIG_fail;
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 (arg1)->RemoveChild(arg2);
28298
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 Py_INCREF(Py_None); resultobj = Py_None;
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28310 PyObject *resultobj;
28311 wxWindow *arg1 = (wxWindow *) 0 ;
28312 long arg2 ;
28313 wxWindow *result;
28314 PyObject * obj0 = 0 ;
28315 PyObject * obj1 = 0 ;
28316 char *kwnames[] = {
28317 (char *) "self",(char *) "winid", NULL
28318 };
28319
28320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(1)) SWIG_fail;
28323 {
28324 arg2 = (long)(SWIG_As_long(obj1));
28325 if (SWIG_arg_fail(2)) SWIG_fail;
28326 }
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (wxWindow *)(arg1)->FindWindow(arg2);
28330
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 {
28335 resultobj = wxPyMake_wxObject(result, 0);
28336 }
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28344 PyObject *resultobj;
28345 wxWindow *arg1 = (wxWindow *) 0 ;
28346 wxString *arg2 = 0 ;
28347 wxWindow *result;
28348 bool temp2 = false ;
28349 PyObject * obj0 = 0 ;
28350 PyObject * obj1 = 0 ;
28351 char *kwnames[] = {
28352 (char *) "self",(char *) "name", NULL
28353 };
28354
28355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28357 if (SWIG_arg_fail(1)) SWIG_fail;
28358 {
28359 arg2 = wxString_in_helper(obj1);
28360 if (arg2 == NULL) SWIG_fail;
28361 temp2 = true;
28362 }
28363 {
28364 PyThreadState* __tstate = wxPyBeginAllowThreads();
28365 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28366
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 {
28371 resultobj = wxPyMake_wxObject(result, 0);
28372 }
28373 {
28374 if (temp2)
28375 delete arg2;
28376 }
28377 return resultobj;
28378 fail:
28379 {
28380 if (temp2)
28381 delete arg2;
28382 }
28383 return NULL;
28384 }
28385
28386
28387 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj;
28389 wxWindow *arg1 = (wxWindow *) 0 ;
28390 wxEvtHandler *result;
28391 PyObject * obj0 = 0 ;
28392 char *kwnames[] = {
28393 (char *) "self", NULL
28394 };
28395
28396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28398 if (SWIG_arg_fail(1)) SWIG_fail;
28399 {
28400 PyThreadState* __tstate = wxPyBeginAllowThreads();
28401 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28402
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 {
28407 resultobj = wxPyMake_wxObject(result, 0);
28408 }
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj;
28417 wxWindow *arg1 = (wxWindow *) 0 ;
28418 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28419 PyObject * obj0 = 0 ;
28420 PyObject * obj1 = 0 ;
28421 char *kwnames[] = {
28422 (char *) "self",(char *) "handler", NULL
28423 };
28424
28425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28427 if (SWIG_arg_fail(1)) SWIG_fail;
28428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28429 if (SWIG_arg_fail(2)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 (arg1)->SetEventHandler(arg2);
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 Py_INCREF(Py_None); resultobj = Py_None;
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28445 PyObject *resultobj;
28446 wxWindow *arg1 = (wxWindow *) 0 ;
28447 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28448 PyObject * obj0 = 0 ;
28449 PyObject * obj1 = 0 ;
28450 char *kwnames[] = {
28451 (char *) "self",(char *) "handler", NULL
28452 };
28453
28454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28456 if (SWIG_arg_fail(1)) SWIG_fail;
28457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28458 if (SWIG_arg_fail(2)) SWIG_fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 (arg1)->PushEventHandler(arg2);
28462
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 Py_INCREF(Py_None); resultobj = Py_None;
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj;
28475 wxWindow *arg1 = (wxWindow *) 0 ;
28476 bool arg2 = (bool) false ;
28477 wxEvtHandler *result;
28478 PyObject * obj0 = 0 ;
28479 PyObject * obj1 = 0 ;
28480 char *kwnames[] = {
28481 (char *) "self",(char *) "deleteHandler", NULL
28482 };
28483
28484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28486 if (SWIG_arg_fail(1)) SWIG_fail;
28487 if (obj1) {
28488 {
28489 arg2 = (bool)(SWIG_As_bool(obj1));
28490 if (SWIG_arg_fail(2)) SWIG_fail;
28491 }
28492 }
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28496
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 {
28501 resultobj = wxPyMake_wxObject(result, 0);
28502 }
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28510 PyObject *resultobj;
28511 wxWindow *arg1 = (wxWindow *) 0 ;
28512 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28513 bool result;
28514 PyObject * obj0 = 0 ;
28515 PyObject * obj1 = 0 ;
28516 char *kwnames[] = {
28517 (char *) "self",(char *) "handler", NULL
28518 };
28519
28520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28522 if (SWIG_arg_fail(1)) SWIG_fail;
28523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28524 if (SWIG_arg_fail(2)) SWIG_fail;
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 result = (bool)(arg1)->RemoveEventHandler(arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 {
28533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28534 }
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28542 PyObject *resultobj;
28543 wxWindow *arg1 = (wxWindow *) 0 ;
28544 wxValidator *arg2 = 0 ;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "validator", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 {
28555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28556 if (SWIG_arg_fail(2)) SWIG_fail;
28557 if (arg2 == NULL) {
28558 SWIG_null_ref("wxValidator");
28559 }
28560 if (SWIG_arg_fail(2)) SWIG_fail;
28561 }
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 (arg1)->SetValidator((wxValidator const &)*arg2);
28565
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 Py_INCREF(Py_None); resultobj = Py_None;
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxWindow *arg1 = (wxWindow *) 0 ;
28579 wxValidator *result;
28580 PyObject * obj0 = 0 ;
28581 char *kwnames[] = {
28582 (char *) "self", NULL
28583 };
28584
28585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28587 if (SWIG_arg_fail(1)) SWIG_fail;
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (wxValidator *)(arg1)->GetValidator();
28591
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 {
28596 resultobj = wxPyMake_wxObject(result, 0);
28597 }
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28605 PyObject *resultobj;
28606 wxWindow *arg1 = (wxWindow *) 0 ;
28607 bool result;
28608 PyObject * obj0 = 0 ;
28609 char *kwnames[] = {
28610 (char *) "self", NULL
28611 };
28612
28613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28615 if (SWIG_arg_fail(1)) SWIG_fail;
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 result = (bool)(arg1)->Validate();
28619
28620 wxPyEndAllowThreads(__tstate);
28621 if (PyErr_Occurred()) SWIG_fail;
28622 }
28623 {
28624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28625 }
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28633 PyObject *resultobj;
28634 wxWindow *arg1 = (wxWindow *) 0 ;
28635 bool result;
28636 PyObject * obj0 = 0 ;
28637 char *kwnames[] = {
28638 (char *) "self", NULL
28639 };
28640
28641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28643 if (SWIG_arg_fail(1)) SWIG_fail;
28644 {
28645 PyThreadState* __tstate = wxPyBeginAllowThreads();
28646 result = (bool)(arg1)->TransferDataToWindow();
28647
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 {
28652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28653 }
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28661 PyObject *resultobj;
28662 wxWindow *arg1 = (wxWindow *) 0 ;
28663 bool result;
28664 PyObject * obj0 = 0 ;
28665 char *kwnames[] = {
28666 (char *) "self", NULL
28667 };
28668
28669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28671 if (SWIG_arg_fail(1)) SWIG_fail;
28672 {
28673 PyThreadState* __tstate = wxPyBeginAllowThreads();
28674 result = (bool)(arg1)->TransferDataFromWindow();
28675
28676 wxPyEndAllowThreads(__tstate);
28677 if (PyErr_Occurred()) SWIG_fail;
28678 }
28679 {
28680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28681 }
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28689 PyObject *resultobj;
28690 wxWindow *arg1 = (wxWindow *) 0 ;
28691 PyObject * obj0 = 0 ;
28692 char *kwnames[] = {
28693 (char *) "self", NULL
28694 };
28695
28696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28698 if (SWIG_arg_fail(1)) SWIG_fail;
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 (arg1)->InitDialog();
28702
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 Py_INCREF(Py_None); resultobj = Py_None;
28707 return resultobj;
28708 fail:
28709 return NULL;
28710 }
28711
28712
28713 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28714 PyObject *resultobj;
28715 wxWindow *arg1 = (wxWindow *) 0 ;
28716 wxAcceleratorTable *arg2 = 0 ;
28717 PyObject * obj0 = 0 ;
28718 PyObject * obj1 = 0 ;
28719 char *kwnames[] = {
28720 (char *) "self",(char *) "accel", NULL
28721 };
28722
28723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28725 if (SWIG_arg_fail(1)) SWIG_fail;
28726 {
28727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28728 if (SWIG_arg_fail(2)) SWIG_fail;
28729 if (arg2 == NULL) {
28730 SWIG_null_ref("wxAcceleratorTable");
28731 }
28732 if (SWIG_arg_fail(2)) SWIG_fail;
28733 }
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28737
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 Py_INCREF(Py_None); resultobj = Py_None;
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj;
28750 wxWindow *arg1 = (wxWindow *) 0 ;
28751 wxAcceleratorTable *result;
28752 PyObject * obj0 = 0 ;
28753 char *kwnames[] = {
28754 (char *) "self", NULL
28755 };
28756
28757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28759 if (SWIG_arg_fail(1)) SWIG_fail;
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28763
28764 wxPyEndAllowThreads(__tstate);
28765 if (PyErr_Occurred()) SWIG_fail;
28766 }
28767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj;
28776 wxWindow *arg1 = (wxWindow *) 0 ;
28777 int arg2 ;
28778 int arg3 ;
28779 int arg4 ;
28780 bool result;
28781 PyObject * obj0 = 0 ;
28782 PyObject * obj1 = 0 ;
28783 PyObject * obj2 = 0 ;
28784 PyObject * obj3 = 0 ;
28785 char *kwnames[] = {
28786 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28787 };
28788
28789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28791 if (SWIG_arg_fail(1)) SWIG_fail;
28792 {
28793 arg2 = (int)(SWIG_As_int(obj1));
28794 if (SWIG_arg_fail(2)) SWIG_fail;
28795 }
28796 {
28797 arg3 = (int)(SWIG_As_int(obj2));
28798 if (SWIG_arg_fail(3)) SWIG_fail;
28799 }
28800 {
28801 arg4 = (int)(SWIG_As_int(obj3));
28802 if (SWIG_arg_fail(4)) SWIG_fail;
28803 }
28804 {
28805 PyThreadState* __tstate = wxPyBeginAllowThreads();
28806 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28807
28808 wxPyEndAllowThreads(__tstate);
28809 if (PyErr_Occurred()) SWIG_fail;
28810 }
28811 {
28812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28813 }
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj;
28822 wxWindow *arg1 = (wxWindow *) 0 ;
28823 int arg2 ;
28824 bool result;
28825 PyObject * obj0 = 0 ;
28826 PyObject * obj1 = 0 ;
28827 char *kwnames[] = {
28828 (char *) "self",(char *) "hotkeyId", NULL
28829 };
28830
28831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28833 if (SWIG_arg_fail(1)) SWIG_fail;
28834 {
28835 arg2 = (int)(SWIG_As_int(obj1));
28836 if (SWIG_arg_fail(2)) SWIG_fail;
28837 }
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28841
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 {
28846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28847 }
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj;
28856 wxWindow *arg1 = (wxWindow *) 0 ;
28857 wxPoint *arg2 = 0 ;
28858 wxPoint result;
28859 wxPoint temp2 ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char *kwnames[] = {
28863 (char *) "self",(char *) "pt", NULL
28864 };
28865
28866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(1)) SWIG_fail;
28869 {
28870 arg2 = &temp2;
28871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28872 }
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 wxPoint * resultptr;
28882 resultptr = new wxPoint((wxPoint &)(result));
28883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj;
28893 wxWindow *arg1 = (wxWindow *) 0 ;
28894 wxSize *arg2 = 0 ;
28895 wxSize result;
28896 wxSize temp2 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 char *kwnames[] = {
28900 (char *) "self",(char *) "sz", NULL
28901 };
28902
28903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28905 if (SWIG_arg_fail(1)) SWIG_fail;
28906 {
28907 arg2 = &temp2;
28908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28909 }
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28913
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 {
28918 wxSize * resultptr;
28919 resultptr = new wxSize((wxSize &)(result));
28920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28921 }
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28929 PyObject *resultobj;
28930 wxWindow *arg1 = (wxWindow *) 0 ;
28931 wxPoint *arg2 = 0 ;
28932 wxPoint result;
28933 wxPoint temp2 ;
28934 PyObject * obj0 = 0 ;
28935 PyObject * obj1 = 0 ;
28936 char *kwnames[] = {
28937 (char *) "self",(char *) "pt", NULL
28938 };
28939
28940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28942 if (SWIG_arg_fail(1)) SWIG_fail;
28943 {
28944 arg2 = &temp2;
28945 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28946 }
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28950
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 {
28955 wxPoint * resultptr;
28956 resultptr = new wxPoint((wxPoint &)(result));
28957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28958 }
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj;
28967 wxWindow *arg1 = (wxWindow *) 0 ;
28968 wxSize *arg2 = 0 ;
28969 wxSize result;
28970 wxSize temp2 ;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char *kwnames[] = {
28974 (char *) "self",(char *) "sz", NULL
28975 };
28976
28977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28979 if (SWIG_arg_fail(1)) SWIG_fail;
28980 {
28981 arg2 = &temp2;
28982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28983 }
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28987
28988 wxPyEndAllowThreads(__tstate);
28989 if (PyErr_Occurred()) SWIG_fail;
28990 }
28991 {
28992 wxSize * resultptr;
28993 resultptr = new wxSize((wxSize &)(result));
28994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28995 }
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29003 PyObject *resultobj;
29004 wxWindow *arg1 = (wxWindow *) 0 ;
29005 wxPoint *arg2 = 0 ;
29006 wxPoint result;
29007 wxPoint temp2 ;
29008 PyObject * obj0 = 0 ;
29009 PyObject * obj1 = 0 ;
29010 char *kwnames[] = {
29011 (char *) "self",(char *) "pt", NULL
29012 };
29013
29014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29016 if (SWIG_arg_fail(1)) SWIG_fail;
29017 {
29018 arg2 = &temp2;
29019 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29020 }
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29024
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 {
29029 wxPoint * resultptr;
29030 resultptr = new wxPoint((wxPoint &)(result));
29031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29032 }
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29040 PyObject *resultobj;
29041 wxWindow *arg1 = (wxWindow *) 0 ;
29042 wxSize *arg2 = 0 ;
29043 wxSize result;
29044 wxSize temp2 ;
29045 PyObject * obj0 = 0 ;
29046 PyObject * obj1 = 0 ;
29047 char *kwnames[] = {
29048 (char *) "self",(char *) "sz", NULL
29049 };
29050
29051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29053 if (SWIG_arg_fail(1)) SWIG_fail;
29054 {
29055 arg2 = &temp2;
29056 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29057 }
29058 {
29059 PyThreadState* __tstate = wxPyBeginAllowThreads();
29060 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29061
29062 wxPyEndAllowThreads(__tstate);
29063 if (PyErr_Occurred()) SWIG_fail;
29064 }
29065 {
29066 wxSize * resultptr;
29067 resultptr = new wxSize((wxSize &)(result));
29068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29069 }
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj;
29078 wxWindow *arg1 = (wxWindow *) 0 ;
29079 int arg2 ;
29080 int arg3 ;
29081 PyObject * obj0 = 0 ;
29082 PyObject * obj1 = 0 ;
29083 PyObject * obj2 = 0 ;
29084 char *kwnames[] = {
29085 (char *) "self",(char *) "x",(char *) "y", NULL
29086 };
29087
29088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29090 if (SWIG_arg_fail(1)) SWIG_fail;
29091 {
29092 arg2 = (int)(SWIG_As_int(obj1));
29093 if (SWIG_arg_fail(2)) SWIG_fail;
29094 }
29095 {
29096 arg3 = (int)(SWIG_As_int(obj2));
29097 if (SWIG_arg_fail(3)) SWIG_fail;
29098 }
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 (arg1)->WarpPointer(arg2,arg3);
29102
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 Py_INCREF(Py_None); resultobj = Py_None;
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29114 PyObject *resultobj;
29115 wxWindow *arg1 = (wxWindow *) 0 ;
29116 PyObject * obj0 = 0 ;
29117 char *kwnames[] = {
29118 (char *) "self", NULL
29119 };
29120
29121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29123 if (SWIG_arg_fail(1)) SWIG_fail;
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 (arg1)->CaptureMouse();
29127
29128 wxPyEndAllowThreads(__tstate);
29129 if (PyErr_Occurred()) SWIG_fail;
29130 }
29131 Py_INCREF(Py_None); resultobj = Py_None;
29132 return resultobj;
29133 fail:
29134 return NULL;
29135 }
29136
29137
29138 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29139 PyObject *resultobj;
29140 wxWindow *arg1 = (wxWindow *) 0 ;
29141 PyObject * obj0 = 0 ;
29142 char *kwnames[] = {
29143 (char *) "self", NULL
29144 };
29145
29146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29148 if (SWIG_arg_fail(1)) SWIG_fail;
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 (arg1)->ReleaseMouse();
29152
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 Py_INCREF(Py_None); resultobj = Py_None;
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29164 PyObject *resultobj;
29165 wxWindow *result;
29166 char *kwnames[] = {
29167 NULL
29168 };
29169
29170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29171 {
29172 if (!wxPyCheckForApp()) SWIG_fail;
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (wxWindow *)wxWindow::GetCapture();
29175
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 {
29180 resultobj = wxPyMake_wxObject(result, 0);
29181 }
29182 return resultobj;
29183 fail:
29184 return NULL;
29185 }
29186
29187
29188 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29189 PyObject *resultobj;
29190 wxWindow *arg1 = (wxWindow *) 0 ;
29191 bool result;
29192 PyObject * obj0 = 0 ;
29193 char *kwnames[] = {
29194 (char *) "self", NULL
29195 };
29196
29197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29199 if (SWIG_arg_fail(1)) SWIG_fail;
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (bool)((wxWindow const *)arg1)->HasCapture();
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 {
29208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxWindow *arg1 = (wxWindow *) 0 ;
29219 bool arg2 = (bool) true ;
29220 wxRect *arg3 = (wxRect *) NULL ;
29221 PyObject * obj0 = 0 ;
29222 PyObject * obj1 = 0 ;
29223 PyObject * obj2 = 0 ;
29224 char *kwnames[] = {
29225 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29226 };
29227
29228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29230 if (SWIG_arg_fail(1)) SWIG_fail;
29231 if (obj1) {
29232 {
29233 arg2 = (bool)(SWIG_As_bool(obj1));
29234 if (SWIG_arg_fail(2)) SWIG_fail;
29235 }
29236 }
29237 if (obj2) {
29238 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29239 if (SWIG_arg_fail(3)) SWIG_fail;
29240 }
29241 {
29242 PyThreadState* __tstate = wxPyBeginAllowThreads();
29243 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29244
29245 wxPyEndAllowThreads(__tstate);
29246 if (PyErr_Occurred()) SWIG_fail;
29247 }
29248 Py_INCREF(Py_None); resultobj = Py_None;
29249 return resultobj;
29250 fail:
29251 return NULL;
29252 }
29253
29254
29255 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29256 PyObject *resultobj;
29257 wxWindow *arg1 = (wxWindow *) 0 ;
29258 wxRect *arg2 = 0 ;
29259 bool arg3 = (bool) true ;
29260 wxRect temp2 ;
29261 PyObject * obj0 = 0 ;
29262 PyObject * obj1 = 0 ;
29263 PyObject * obj2 = 0 ;
29264 char *kwnames[] = {
29265 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29266 };
29267
29268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29270 if (SWIG_arg_fail(1)) SWIG_fail;
29271 {
29272 arg2 = &temp2;
29273 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29274 }
29275 if (obj2) {
29276 {
29277 arg3 = (bool)(SWIG_As_bool(obj2));
29278 if (SWIG_arg_fail(3)) SWIG_fail;
29279 }
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29284
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 Py_INCREF(Py_None); resultobj = Py_None;
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29296 PyObject *resultobj;
29297 wxWindow *arg1 = (wxWindow *) 0 ;
29298 PyObject * obj0 = 0 ;
29299 char *kwnames[] = {
29300 (char *) "self", NULL
29301 };
29302
29303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29305 if (SWIG_arg_fail(1)) SWIG_fail;
29306 {
29307 PyThreadState* __tstate = wxPyBeginAllowThreads();
29308 (arg1)->Update();
29309
29310 wxPyEndAllowThreads(__tstate);
29311 if (PyErr_Occurred()) SWIG_fail;
29312 }
29313 Py_INCREF(Py_None); resultobj = Py_None;
29314 return resultobj;
29315 fail:
29316 return NULL;
29317 }
29318
29319
29320 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29321 PyObject *resultobj;
29322 wxWindow *arg1 = (wxWindow *) 0 ;
29323 PyObject * obj0 = 0 ;
29324 char *kwnames[] = {
29325 (char *) "self", NULL
29326 };
29327
29328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29330 if (SWIG_arg_fail(1)) SWIG_fail;
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 (arg1)->ClearBackground();
29334
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 Py_INCREF(Py_None); resultobj = Py_None;
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29346 PyObject *resultobj;
29347 wxWindow *arg1 = (wxWindow *) 0 ;
29348 PyObject * obj0 = 0 ;
29349 char *kwnames[] = {
29350 (char *) "self", NULL
29351 };
29352
29353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(1)) SWIG_fail;
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 (arg1)->Freeze();
29359
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 Py_INCREF(Py_None); resultobj = Py_None;
29364 return resultobj;
29365 fail:
29366 return NULL;
29367 }
29368
29369
29370 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29371 PyObject *resultobj;
29372 wxWindow *arg1 = (wxWindow *) 0 ;
29373 PyObject * obj0 = 0 ;
29374 char *kwnames[] = {
29375 (char *) "self", NULL
29376 };
29377
29378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29380 if (SWIG_arg_fail(1)) SWIG_fail;
29381 {
29382 PyThreadState* __tstate = wxPyBeginAllowThreads();
29383 (arg1)->Thaw();
29384
29385 wxPyEndAllowThreads(__tstate);
29386 if (PyErr_Occurred()) SWIG_fail;
29387 }
29388 Py_INCREF(Py_None); resultobj = Py_None;
29389 return resultobj;
29390 fail:
29391 return NULL;
29392 }
29393
29394
29395 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29396 PyObject *resultobj;
29397 wxWindow *arg1 = (wxWindow *) 0 ;
29398 wxDC *arg2 = 0 ;
29399 PyObject * obj0 = 0 ;
29400 PyObject * obj1 = 0 ;
29401 char *kwnames[] = {
29402 (char *) "self",(char *) "dc", NULL
29403 };
29404
29405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29407 if (SWIG_arg_fail(1)) SWIG_fail;
29408 {
29409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29410 if (SWIG_arg_fail(2)) SWIG_fail;
29411 if (arg2 == NULL) {
29412 SWIG_null_ref("wxDC");
29413 }
29414 if (SWIG_arg_fail(2)) SWIG_fail;
29415 }
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 (arg1)->PrepareDC(*arg2);
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 Py_INCREF(Py_None); resultobj = Py_None;
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj;
29432 wxWindow *arg1 = (wxWindow *) 0 ;
29433 wxRegion *result;
29434 PyObject * obj0 = 0 ;
29435 char *kwnames[] = {
29436 (char *) "self", NULL
29437 };
29438
29439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29441 if (SWIG_arg_fail(1)) SWIG_fail;
29442 {
29443 PyThreadState* __tstate = wxPyBeginAllowThreads();
29444 {
29445 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29446 result = (wxRegion *) &_result_ref;
29447 }
29448
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj;
29461 wxWindow *arg1 = (wxWindow *) 0 ;
29462 wxRect result;
29463 PyObject * obj0 = 0 ;
29464 char *kwnames[] = {
29465 (char *) "self", NULL
29466 };
29467
29468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29470 if (SWIG_arg_fail(1)) SWIG_fail;
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29474
29475 wxPyEndAllowThreads(__tstate);
29476 if (PyErr_Occurred()) SWIG_fail;
29477 }
29478 {
29479 wxRect * resultptr;
29480 resultptr = new wxRect((wxRect &)(result));
29481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29482 }
29483 return resultobj;
29484 fail:
29485 return NULL;
29486 }
29487
29488
29489 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29490 PyObject *resultobj;
29491 wxWindow *arg1 = (wxWindow *) 0 ;
29492 int arg2 ;
29493 int arg3 ;
29494 int arg4 = (int) 1 ;
29495 int arg5 = (int) 1 ;
29496 bool result;
29497 PyObject * obj0 = 0 ;
29498 PyObject * obj1 = 0 ;
29499 PyObject * obj2 = 0 ;
29500 PyObject * obj3 = 0 ;
29501 PyObject * obj4 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 arg2 = (int)(SWIG_As_int(obj1));
29511 if (SWIG_arg_fail(2)) SWIG_fail;
29512 }
29513 {
29514 arg3 = (int)(SWIG_As_int(obj2));
29515 if (SWIG_arg_fail(3)) SWIG_fail;
29516 }
29517 if (obj3) {
29518 {
29519 arg4 = (int)(SWIG_As_int(obj3));
29520 if (SWIG_arg_fail(4)) SWIG_fail;
29521 }
29522 }
29523 if (obj4) {
29524 {
29525 arg5 = (int)(SWIG_As_int(obj4));
29526 if (SWIG_arg_fail(5)) SWIG_fail;
29527 }
29528 }
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29532
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 {
29537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29538 }
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxWindow *arg1 = (wxWindow *) 0 ;
29548 wxPoint *arg2 = 0 ;
29549 bool result;
29550 wxPoint temp2 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self",(char *) "pt", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 {
29561 arg2 = &temp2;
29562 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxWindow *arg1 = (wxWindow *) 0 ;
29583 wxRect *arg2 = 0 ;
29584 bool result;
29585 wxRect temp2 ;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 char *kwnames[] = {
29589 (char *) "self",(char *) "rect", NULL
29590 };
29591
29592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29594 if (SWIG_arg_fail(1)) SWIG_fail;
29595 {
29596 arg2 = &temp2;
29597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29598 }
29599 {
29600 PyThreadState* __tstate = wxPyBeginAllowThreads();
29601 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29602
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 {
29607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29608 }
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj;
29617 wxWindow *arg1 = (wxWindow *) 0 ;
29618 wxVisualAttributes result;
29619 PyObject * obj0 = 0 ;
29620 char *kwnames[] = {
29621 (char *) "self", NULL
29622 };
29623
29624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29626 if (SWIG_arg_fail(1)) SWIG_fail;
29627 {
29628 PyThreadState* __tstate = wxPyBeginAllowThreads();
29629 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29630
29631 wxPyEndAllowThreads(__tstate);
29632 if (PyErr_Occurred()) SWIG_fail;
29633 }
29634 {
29635 wxVisualAttributes * resultptr;
29636 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29638 }
29639 return resultobj;
29640 fail:
29641 return NULL;
29642 }
29643
29644
29645 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29646 PyObject *resultobj;
29647 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29648 wxVisualAttributes result;
29649 PyObject * obj0 = 0 ;
29650 char *kwnames[] = {
29651 (char *) "variant", NULL
29652 };
29653
29654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29655 if (obj0) {
29656 {
29657 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29658 if (SWIG_arg_fail(1)) SWIG_fail;
29659 }
29660 }
29661 {
29662 if (!wxPyCheckForApp()) SWIG_fail;
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29665
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 {
29670 wxVisualAttributes * resultptr;
29671 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29673 }
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29681 PyObject *resultobj;
29682 wxWindow *arg1 = (wxWindow *) 0 ;
29683 wxColour *arg2 = 0 ;
29684 bool result;
29685 wxColour temp2 ;
29686 PyObject * obj0 = 0 ;
29687 PyObject * obj1 = 0 ;
29688 char *kwnames[] = {
29689 (char *) "self",(char *) "colour", NULL
29690 };
29691
29692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29694 if (SWIG_arg_fail(1)) SWIG_fail;
29695 {
29696 arg2 = &temp2;
29697 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29698 }
29699 {
29700 PyThreadState* __tstate = wxPyBeginAllowThreads();
29701 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29702
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 {
29707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29708 }
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj;
29717 wxWindow *arg1 = (wxWindow *) 0 ;
29718 wxColour *arg2 = 0 ;
29719 wxColour temp2 ;
29720 PyObject * obj0 = 0 ;
29721 PyObject * obj1 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self",(char *) "colour", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 arg2 = &temp2;
29731 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29732 }
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29736
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 Py_INCREF(Py_None); resultobj = Py_None;
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj;
29749 wxWindow *arg1 = (wxWindow *) 0 ;
29750 wxColour *arg2 = 0 ;
29751 bool result;
29752 wxColour temp2 ;
29753 PyObject * obj0 = 0 ;
29754 PyObject * obj1 = 0 ;
29755 char *kwnames[] = {
29756 (char *) "self",(char *) "colour", NULL
29757 };
29758
29759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(1)) SWIG_fail;
29762 {
29763 arg2 = &temp2;
29764 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29765 }
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 {
29774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29775 }
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxWindow *arg1 = (wxWindow *) 0 ;
29785 wxColour *arg2 = 0 ;
29786 wxColour temp2 ;
29787 PyObject * obj0 = 0 ;
29788 PyObject * obj1 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self",(char *) "colour", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 arg2 = &temp2;
29798 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29799 }
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 Py_INCREF(Py_None); resultobj = Py_None;
29808 return resultobj;
29809 fail:
29810 return NULL;
29811 }
29812
29813
29814 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 wxWindow *arg1 = (wxWindow *) 0 ;
29817 wxColour result;
29818 PyObject * obj0 = 0 ;
29819 char *kwnames[] = {
29820 (char *) "self", NULL
29821 };
29822
29823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29825 if (SWIG_arg_fail(1)) SWIG_fail;
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29829
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 wxColour * resultptr;
29835 resultptr = new wxColour((wxColour &)(result));
29836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29837 }
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj;
29846 wxWindow *arg1 = (wxWindow *) 0 ;
29847 wxColour result;
29848 PyObject * obj0 = 0 ;
29849 char *kwnames[] = {
29850 (char *) "self", NULL
29851 };
29852
29853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29855 if (SWIG_arg_fail(1)) SWIG_fail;
29856 {
29857 PyThreadState* __tstate = wxPyBeginAllowThreads();
29858 result = ((wxWindow const *)arg1)->GetForegroundColour();
29859
29860 wxPyEndAllowThreads(__tstate);
29861 if (PyErr_Occurred()) SWIG_fail;
29862 }
29863 {
29864 wxColour * resultptr;
29865 resultptr = new wxColour((wxColour &)(result));
29866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29867 }
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj;
29876 wxWindow *arg1 = (wxWindow *) 0 ;
29877 bool result;
29878 PyObject * obj0 = 0 ;
29879 char *kwnames[] = {
29880 (char *) "self", NULL
29881 };
29882
29883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29885 if (SWIG_arg_fail(1)) SWIG_fail;
29886 {
29887 PyThreadState* __tstate = wxPyBeginAllowThreads();
29888 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29889
29890 wxPyEndAllowThreads(__tstate);
29891 if (PyErr_Occurred()) SWIG_fail;
29892 }
29893 {
29894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29895 }
29896 return resultobj;
29897 fail:
29898 return NULL;
29899 }
29900
29901
29902 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29903 PyObject *resultobj;
29904 wxWindow *arg1 = (wxWindow *) 0 ;
29905 bool result;
29906 PyObject * obj0 = 0 ;
29907 char *kwnames[] = {
29908 (char *) "self", NULL
29909 };
29910
29911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29913 if (SWIG_arg_fail(1)) SWIG_fail;
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29917
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 {
29922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29923 }
29924 return resultobj;
29925 fail:
29926 return NULL;
29927 }
29928
29929
29930 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29931 PyObject *resultobj;
29932 wxWindow *arg1 = (wxWindow *) 0 ;
29933 wxBackgroundStyle arg2 ;
29934 bool result;
29935 PyObject * obj0 = 0 ;
29936 PyObject * obj1 = 0 ;
29937 char *kwnames[] = {
29938 (char *) "self",(char *) "style", NULL
29939 };
29940
29941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29943 if (SWIG_arg_fail(1)) SWIG_fail;
29944 {
29945 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29946 if (SWIG_arg_fail(2)) SWIG_fail;
29947 }
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29951
29952 wxPyEndAllowThreads(__tstate);
29953 if (PyErr_Occurred()) SWIG_fail;
29954 }
29955 {
29956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29957 }
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29965 PyObject *resultobj;
29966 wxWindow *arg1 = (wxWindow *) 0 ;
29967 wxBackgroundStyle result;
29968 PyObject * obj0 = 0 ;
29969 char *kwnames[] = {
29970 (char *) "self", NULL
29971 };
29972
29973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29975 if (SWIG_arg_fail(1)) SWIG_fail;
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29979
29980 wxPyEndAllowThreads(__tstate);
29981 if (PyErr_Occurred()) SWIG_fail;
29982 }
29983 resultobj = SWIG_From_int((result));
29984 return resultobj;
29985 fail:
29986 return NULL;
29987 }
29988
29989
29990 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29991 PyObject *resultobj;
29992 wxWindow *arg1 = (wxWindow *) 0 ;
29993 bool result;
29994 PyObject * obj0 = 0 ;
29995 char *kwnames[] = {
29996 (char *) "self", NULL
29997 };
29998
29999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(1)) SWIG_fail;
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (bool)(arg1)->HasTransparentBackground();
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 {
30010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj;
30020 wxWindow *arg1 = (wxWindow *) 0 ;
30021 wxCursor *arg2 = 0 ;
30022 bool result;
30023 PyObject * obj0 = 0 ;
30024 PyObject * obj1 = 0 ;
30025 char *kwnames[] = {
30026 (char *) "self",(char *) "cursor", NULL
30027 };
30028
30029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30031 if (SWIG_arg_fail(1)) SWIG_fail;
30032 {
30033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30034 if (SWIG_arg_fail(2)) SWIG_fail;
30035 if (arg2 == NULL) {
30036 SWIG_null_ref("wxCursor");
30037 }
30038 if (SWIG_arg_fail(2)) SWIG_fail;
30039 }
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30043
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 {
30048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30049 }
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj;
30058 wxWindow *arg1 = (wxWindow *) 0 ;
30059 wxCursor result;
30060 PyObject * obj0 = 0 ;
30061 char *kwnames[] = {
30062 (char *) "self", NULL
30063 };
30064
30065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30067 if (SWIG_arg_fail(1)) SWIG_fail;
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (arg1)->GetCursor();
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 {
30076 wxCursor * resultptr;
30077 resultptr = new wxCursor((wxCursor &)(result));
30078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30079 }
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxWindow *arg1 = (wxWindow *) 0 ;
30089 wxFont *arg2 = 0 ;
30090 bool result;
30091 PyObject * obj0 = 0 ;
30092 PyObject * obj1 = 0 ;
30093 char *kwnames[] = {
30094 (char *) "self",(char *) "font", NULL
30095 };
30096
30097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30099 if (SWIG_arg_fail(1)) SWIG_fail;
30100 {
30101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30102 if (SWIG_arg_fail(2)) SWIG_fail;
30103 if (arg2 == NULL) {
30104 SWIG_null_ref("wxFont");
30105 }
30106 if (SWIG_arg_fail(2)) SWIG_fail;
30107 }
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30111
30112 wxPyEndAllowThreads(__tstate);
30113 if (PyErr_Occurred()) SWIG_fail;
30114 }
30115 {
30116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30117 }
30118 return resultobj;
30119 fail:
30120 return NULL;
30121 }
30122
30123
30124 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30125 PyObject *resultobj;
30126 wxWindow *arg1 = (wxWindow *) 0 ;
30127 wxFont *arg2 = 0 ;
30128 PyObject * obj0 = 0 ;
30129 PyObject * obj1 = 0 ;
30130 char *kwnames[] = {
30131 (char *) "self",(char *) "font", NULL
30132 };
30133
30134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 {
30138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30139 if (SWIG_arg_fail(2)) SWIG_fail;
30140 if (arg2 == NULL) {
30141 SWIG_null_ref("wxFont");
30142 }
30143 if (SWIG_arg_fail(2)) SWIG_fail;
30144 }
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 (arg1)->SetOwnFont((wxFont const &)*arg2);
30148
30149 wxPyEndAllowThreads(__tstate);
30150 if (PyErr_Occurred()) SWIG_fail;
30151 }
30152 Py_INCREF(Py_None); resultobj = Py_None;
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30160 PyObject *resultobj;
30161 wxWindow *arg1 = (wxWindow *) 0 ;
30162 wxFont result;
30163 PyObject * obj0 = 0 ;
30164 char *kwnames[] = {
30165 (char *) "self", NULL
30166 };
30167
30168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30170 if (SWIG_arg_fail(1)) SWIG_fail;
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (arg1)->GetFont();
30174
30175 wxPyEndAllowThreads(__tstate);
30176 if (PyErr_Occurred()) SWIG_fail;
30177 }
30178 {
30179 wxFont * resultptr;
30180 resultptr = new wxFont((wxFont &)(result));
30181 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30182 }
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj;
30191 wxWindow *arg1 = (wxWindow *) 0 ;
30192 wxCaret *arg2 = (wxCaret *) 0 ;
30193 PyObject * obj0 = 0 ;
30194 PyObject * obj1 = 0 ;
30195 char *kwnames[] = {
30196 (char *) "self",(char *) "caret", NULL
30197 };
30198
30199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30201 if (SWIG_arg_fail(1)) SWIG_fail;
30202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30203 if (SWIG_arg_fail(2)) SWIG_fail;
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->SetCaret(arg2);
30207
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 Py_INCREF(Py_None); resultobj = Py_None;
30212 return resultobj;
30213 fail:
30214 return NULL;
30215 }
30216
30217
30218 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj;
30220 wxWindow *arg1 = (wxWindow *) 0 ;
30221 wxCaret *result;
30222 PyObject * obj0 = 0 ;
30223 char *kwnames[] = {
30224 (char *) "self", NULL
30225 };
30226
30227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30229 if (SWIG_arg_fail(1)) SWIG_fail;
30230 {
30231 PyThreadState* __tstate = wxPyBeginAllowThreads();
30232 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30233
30234 wxPyEndAllowThreads(__tstate);
30235 if (PyErr_Occurred()) SWIG_fail;
30236 }
30237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30245 PyObject *resultobj;
30246 wxWindow *arg1 = (wxWindow *) 0 ;
30247 int result;
30248 PyObject * obj0 = 0 ;
30249 char *kwnames[] = {
30250 (char *) "self", NULL
30251 };
30252
30253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30255 if (SWIG_arg_fail(1)) SWIG_fail;
30256 {
30257 PyThreadState* __tstate = wxPyBeginAllowThreads();
30258 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30259
30260 wxPyEndAllowThreads(__tstate);
30261 if (PyErr_Occurred()) SWIG_fail;
30262 }
30263 {
30264 resultobj = SWIG_From_int((int)(result));
30265 }
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj;
30274 wxWindow *arg1 = (wxWindow *) 0 ;
30275 int result;
30276 PyObject * obj0 = 0 ;
30277 char *kwnames[] = {
30278 (char *) "self", NULL
30279 };
30280
30281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30283 if (SWIG_arg_fail(1)) SWIG_fail;
30284 {
30285 PyThreadState* __tstate = wxPyBeginAllowThreads();
30286 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30287
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 {
30292 resultobj = SWIG_From_int((int)(result));
30293 }
30294 return resultobj;
30295 fail:
30296 return NULL;
30297 }
30298
30299
30300 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30301 PyObject *resultobj;
30302 wxWindow *arg1 = (wxWindow *) 0 ;
30303 wxString *arg2 = 0 ;
30304 int *arg3 = (int *) 0 ;
30305 int *arg4 = (int *) 0 ;
30306 bool temp2 = false ;
30307 int temp3 ;
30308 int res3 = 0 ;
30309 int temp4 ;
30310 int res4 = 0 ;
30311 PyObject * obj0 = 0 ;
30312 PyObject * obj1 = 0 ;
30313 char *kwnames[] = {
30314 (char *) "self",(char *) "string", NULL
30315 };
30316
30317 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30318 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30321 if (SWIG_arg_fail(1)) SWIG_fail;
30322 {
30323 arg2 = wxString_in_helper(obj1);
30324 if (arg2 == NULL) SWIG_fail;
30325 temp2 = true;
30326 }
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30330
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 Py_INCREF(Py_None); resultobj = Py_None;
30335 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30336 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30337 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30338 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30339 {
30340 if (temp2)
30341 delete arg2;
30342 }
30343 return resultobj;
30344 fail:
30345 {
30346 if (temp2)
30347 delete arg2;
30348 }
30349 return NULL;
30350 }
30351
30352
30353 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 wxString *arg2 = 0 ;
30357 int *arg3 = (int *) 0 ;
30358 int *arg4 = (int *) 0 ;
30359 int *arg5 = (int *) 0 ;
30360 int *arg6 = (int *) 0 ;
30361 wxFont *arg7 = (wxFont *) NULL ;
30362 bool temp2 = false ;
30363 int temp3 ;
30364 int res3 = 0 ;
30365 int temp4 ;
30366 int res4 = 0 ;
30367 int temp5 ;
30368 int res5 = 0 ;
30369 int temp6 ;
30370 int res6 = 0 ;
30371 PyObject * obj0 = 0 ;
30372 PyObject * obj1 = 0 ;
30373 PyObject * obj2 = 0 ;
30374 char *kwnames[] = {
30375 (char *) "self",(char *) "string",(char *) "font", NULL
30376 };
30377
30378 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30379 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30380 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30381 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30384 if (SWIG_arg_fail(1)) SWIG_fail;
30385 {
30386 arg2 = wxString_in_helper(obj1);
30387 if (arg2 == NULL) SWIG_fail;
30388 temp2 = true;
30389 }
30390 if (obj2) {
30391 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30392 if (SWIG_arg_fail(7)) SWIG_fail;
30393 }
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 Py_INCREF(Py_None); resultobj = Py_None;
30402 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30403 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30404 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30405 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30406 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30407 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30408 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30409 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30410 {
30411 if (temp2)
30412 delete arg2;
30413 }
30414 return resultobj;
30415 fail:
30416 {
30417 if (temp2)
30418 delete arg2;
30419 }
30420 return NULL;
30421 }
30422
30423
30424 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj;
30426 wxWindow *arg1 = (wxWindow *) 0 ;
30427 int *arg2 = (int *) 0 ;
30428 int *arg3 = (int *) 0 ;
30429 int temp2 ;
30430 int res2 = 0 ;
30431 int temp3 ;
30432 int res3 = 0 ;
30433 PyObject * obj0 = 0 ;
30434 PyObject * obj1 = 0 ;
30435 PyObject * obj2 = 0 ;
30436 char *kwnames[] = {
30437 (char *) "self",(char *) "x",(char *) "y", NULL
30438 };
30439
30440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(1)) SWIG_fail;
30443 {
30444 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30445 temp2 = SWIG_As_int(obj1);
30446 if (SWIG_arg_fail(2)) SWIG_fail;
30447 arg2 = &temp2;
30448 res2 = SWIG_NEWOBJ;
30449 }
30450 }
30451 {
30452 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30453 temp3 = SWIG_As_int(obj2);
30454 if (SWIG_arg_fail(3)) SWIG_fail;
30455 arg3 = &temp3;
30456 res3 = SWIG_NEWOBJ;
30457 }
30458 }
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30462
30463 wxPyEndAllowThreads(__tstate);
30464 if (PyErr_Occurred()) SWIG_fail;
30465 }
30466 Py_INCREF(Py_None); resultobj = Py_None;
30467 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30468 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30469 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30470 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30478 PyObject *resultobj;
30479 wxWindow *arg1 = (wxWindow *) 0 ;
30480 int *arg2 = (int *) 0 ;
30481 int *arg3 = (int *) 0 ;
30482 int temp2 ;
30483 int res2 = 0 ;
30484 int temp3 ;
30485 int res3 = 0 ;
30486 PyObject * obj0 = 0 ;
30487 PyObject * obj1 = 0 ;
30488 PyObject * obj2 = 0 ;
30489 char *kwnames[] = {
30490 (char *) "self",(char *) "x",(char *) "y", NULL
30491 };
30492
30493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30495 if (SWIG_arg_fail(1)) SWIG_fail;
30496 {
30497 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30498 temp2 = SWIG_As_int(obj1);
30499 if (SWIG_arg_fail(2)) SWIG_fail;
30500 arg2 = &temp2;
30501 res2 = SWIG_NEWOBJ;
30502 }
30503 }
30504 {
30505 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30506 temp3 = SWIG_As_int(obj2);
30507 if (SWIG_arg_fail(3)) SWIG_fail;
30508 arg3 = &temp3;
30509 res3 = SWIG_NEWOBJ;
30510 }
30511 }
30512 {
30513 PyThreadState* __tstate = wxPyBeginAllowThreads();
30514 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30515
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 Py_INCREF(Py_None); resultobj = Py_None;
30520 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30521 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30522 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30523 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30531 PyObject *resultobj;
30532 wxWindow *arg1 = (wxWindow *) 0 ;
30533 wxPoint *arg2 = 0 ;
30534 wxPoint result;
30535 wxPoint temp2 ;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 char *kwnames[] = {
30539 (char *) "self",(char *) "pt", NULL
30540 };
30541
30542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30544 if (SWIG_arg_fail(1)) SWIG_fail;
30545 {
30546 arg2 = &temp2;
30547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30548 }
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30552
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 {
30557 wxPoint * resultptr;
30558 resultptr = new wxPoint((wxPoint &)(result));
30559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30560 }
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj;
30569 wxWindow *arg1 = (wxWindow *) 0 ;
30570 wxPoint *arg2 = 0 ;
30571 wxPoint result;
30572 wxPoint temp2 ;
30573 PyObject * obj0 = 0 ;
30574 PyObject * obj1 = 0 ;
30575 char *kwnames[] = {
30576 (char *) "self",(char *) "pt", NULL
30577 };
30578
30579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30581 if (SWIG_arg_fail(1)) SWIG_fail;
30582 {
30583 arg2 = &temp2;
30584 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30585 }
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30589
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 {
30594 wxPoint * resultptr;
30595 resultptr = new wxPoint((wxPoint &)(result));
30596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30597 }
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj;
30606 wxWindow *arg1 = (wxWindow *) 0 ;
30607 int arg2 ;
30608 int arg3 ;
30609 wxHitTest result;
30610 PyObject * obj0 = 0 ;
30611 PyObject * obj1 = 0 ;
30612 PyObject * obj2 = 0 ;
30613 char *kwnames[] = {
30614 (char *) "self",(char *) "x",(char *) "y", NULL
30615 };
30616
30617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30619 if (SWIG_arg_fail(1)) SWIG_fail;
30620 {
30621 arg2 = (int)(SWIG_As_int(obj1));
30622 if (SWIG_arg_fail(2)) SWIG_fail;
30623 }
30624 {
30625 arg3 = (int)(SWIG_As_int(obj2));
30626 if (SWIG_arg_fail(3)) SWIG_fail;
30627 }
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30631
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 resultobj = SWIG_From_int((result));
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj;
30644 wxWindow *arg1 = (wxWindow *) 0 ;
30645 wxPoint *arg2 = 0 ;
30646 wxHitTest result;
30647 wxPoint temp2 ;
30648 PyObject * obj0 = 0 ;
30649 PyObject * obj1 = 0 ;
30650 char *kwnames[] = {
30651 (char *) "self",(char *) "pt", NULL
30652 };
30653
30654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30656 if (SWIG_arg_fail(1)) SWIG_fail;
30657 {
30658 arg2 = &temp2;
30659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30660 }
30661 {
30662 PyThreadState* __tstate = wxPyBeginAllowThreads();
30663 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30664
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = SWIG_From_int((result));
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30676 PyObject *resultobj;
30677 wxWindow *arg1 = (wxWindow *) 0 ;
30678 long arg2 ;
30679 wxBorder result;
30680 PyObject * obj0 = 0 ;
30681 PyObject * obj1 = 0 ;
30682
30683 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30685 if (SWIG_arg_fail(1)) SWIG_fail;
30686 {
30687 arg2 = (long)(SWIG_As_long(obj1));
30688 if (SWIG_arg_fail(2)) SWIG_fail;
30689 }
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30693
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_From_int((result));
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30705 PyObject *resultobj;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 wxBorder result;
30708 PyObject * obj0 = 0 ;
30709
30710 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30712 if (SWIG_arg_fail(1)) SWIG_fail;
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30716
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 resultobj = SWIG_From_int((result));
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30728 int argc;
30729 PyObject *argv[3];
30730 int ii;
30731
30732 argc = PyObject_Length(args);
30733 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30734 argv[ii] = PyTuple_GetItem(args,ii);
30735 }
30736 if (argc == 1) {
30737 int _v;
30738 {
30739 void *ptr;
30740 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30741 _v = 0;
30742 PyErr_Clear();
30743 } else {
30744 _v = 1;
30745 }
30746 }
30747 if (_v) {
30748 return _wrap_Window_GetBorder__SWIG_1(self,args);
30749 }
30750 }
30751 if (argc == 2) {
30752 int _v;
30753 {
30754 void *ptr;
30755 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30756 _v = 0;
30757 PyErr_Clear();
30758 } else {
30759 _v = 1;
30760 }
30761 }
30762 if (_v) {
30763 _v = SWIG_Check_long(argv[1]);
30764 if (_v) {
30765 return _wrap_Window_GetBorder__SWIG_0(self,args);
30766 }
30767 }
30768 }
30769
30770 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30771 return NULL;
30772 }
30773
30774
30775 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj;
30777 wxWindow *arg1 = (wxWindow *) 0 ;
30778 long arg2 = (long) wxUPDATE_UI_NONE ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self",(char *) "flags", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 if (obj1) {
30789 {
30790 arg2 = (long)(SWIG_As_long(obj1));
30791 if (SWIG_arg_fail(2)) SWIG_fail;
30792 }
30793 }
30794 {
30795 PyThreadState* __tstate = wxPyBeginAllowThreads();
30796 (arg1)->UpdateWindowUI(arg2);
30797
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 Py_INCREF(Py_None); resultobj = Py_None;
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30809 PyObject *resultobj;
30810 wxWindow *arg1 = (wxWindow *) 0 ;
30811 wxMenu *arg2 = (wxMenu *) 0 ;
30812 int arg3 = (int) -1 ;
30813 int arg4 = (int) -1 ;
30814 bool result;
30815 PyObject * obj0 = 0 ;
30816 PyObject * obj1 = 0 ;
30817 PyObject * obj2 = 0 ;
30818 PyObject * obj3 = 0 ;
30819 char *kwnames[] = {
30820 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30821 };
30822
30823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30825 if (SWIG_arg_fail(1)) SWIG_fail;
30826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30827 if (SWIG_arg_fail(2)) SWIG_fail;
30828 if (obj2) {
30829 {
30830 arg3 = (int)(SWIG_As_int(obj2));
30831 if (SWIG_arg_fail(3)) SWIG_fail;
30832 }
30833 }
30834 if (obj3) {
30835 {
30836 arg4 = (int)(SWIG_As_int(obj3));
30837 if (SWIG_arg_fail(4)) SWIG_fail;
30838 }
30839 }
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30843
30844 wxPyEndAllowThreads(__tstate);
30845 if (PyErr_Occurred()) SWIG_fail;
30846 }
30847 {
30848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30849 }
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30857 PyObject *resultobj;
30858 wxWindow *arg1 = (wxWindow *) 0 ;
30859 wxMenu *arg2 = (wxMenu *) 0 ;
30860 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30861 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30862 bool result;
30863 wxPoint temp3 ;
30864 PyObject * obj0 = 0 ;
30865 PyObject * obj1 = 0 ;
30866 PyObject * obj2 = 0 ;
30867 char *kwnames[] = {
30868 (char *) "self",(char *) "menu",(char *) "pos", NULL
30869 };
30870
30871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30873 if (SWIG_arg_fail(1)) SWIG_fail;
30874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30875 if (SWIG_arg_fail(2)) SWIG_fail;
30876 if (obj2) {
30877 {
30878 arg3 = &temp3;
30879 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30880 }
30881 }
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30885
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 {
30890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30891 }
30892 return resultobj;
30893 fail:
30894 return NULL;
30895 }
30896
30897
30898 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30899 PyObject *resultobj;
30900 wxWindow *arg1 = (wxWindow *) 0 ;
30901 long result;
30902 PyObject * obj0 = 0 ;
30903 char *kwnames[] = {
30904 (char *) "self", NULL
30905 };
30906
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 result = (long)wxWindow_GetHandle(arg1);
30913
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 {
30918 resultobj = SWIG_From_long((long)(result));
30919 }
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30927 PyObject *resultobj;
30928 wxWindow *arg1 = (wxWindow *) 0 ;
30929 long arg2 ;
30930 PyObject * obj0 = 0 ;
30931 PyObject * obj1 = 0 ;
30932 char *kwnames[] = {
30933 (char *) "self",(char *) "handle", NULL
30934 };
30935
30936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30938 if (SWIG_arg_fail(1)) SWIG_fail;
30939 {
30940 arg2 = (long)(SWIG_As_long(obj1));
30941 if (SWIG_arg_fail(2)) SWIG_fail;
30942 }
30943 {
30944 PyThreadState* __tstate = wxPyBeginAllowThreads();
30945 wxWindow_AssociateHandle(arg1,arg2);
30946
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 Py_INCREF(Py_None); resultobj = Py_None;
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30958 PyObject *resultobj;
30959 wxWindow *arg1 = (wxWindow *) 0 ;
30960 PyObject * obj0 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 (arg1)->DissociateHandle();
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 Py_INCREF(Py_None); resultobj = Py_None;
30976 return resultobj;
30977 fail:
30978 return NULL;
30979 }
30980
30981
30982 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30983 PyObject *resultobj;
30984 wxWindow *arg1 = (wxWindow *) 0 ;
30985 wxPaintEvent *arg2 = 0 ;
30986 PyObject * obj0 = 0 ;
30987 PyObject * obj1 = 0 ;
30988 char *kwnames[] = {
30989 (char *) "self",(char *) "event", NULL
30990 };
30991
30992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30994 if (SWIG_arg_fail(1)) SWIG_fail;
30995 {
30996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30997 if (SWIG_arg_fail(2)) SWIG_fail;
30998 if (arg2 == NULL) {
30999 SWIG_null_ref("wxPaintEvent");
31000 }
31001 if (SWIG_arg_fail(2)) SWIG_fail;
31002 }
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 (arg1)->OnPaint(*arg2);
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 Py_INCREF(Py_None); resultobj = Py_None;
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj;
31019 wxWindow *arg1 = (wxWindow *) 0 ;
31020 int arg2 ;
31021 bool result;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 char *kwnames[] = {
31025 (char *) "self",(char *) "orient", NULL
31026 };
31027
31028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31030 if (SWIG_arg_fail(1)) SWIG_fail;
31031 {
31032 arg2 = (int)(SWIG_As_int(obj1));
31033 if (SWIG_arg_fail(2)) SWIG_fail;
31034 }
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 {
31043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 int arg2 ;
31055 int arg3 ;
31056 int arg4 ;
31057 int arg5 ;
31058 bool arg6 = (bool) true ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 PyObject * obj3 = 0 ;
31063 PyObject * obj4 = 0 ;
31064 PyObject * obj5 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 arg2 = (int)(SWIG_As_int(obj1));
31074 if (SWIG_arg_fail(2)) SWIG_fail;
31075 }
31076 {
31077 arg3 = (int)(SWIG_As_int(obj2));
31078 if (SWIG_arg_fail(3)) SWIG_fail;
31079 }
31080 {
31081 arg4 = (int)(SWIG_As_int(obj3));
31082 if (SWIG_arg_fail(4)) SWIG_fail;
31083 }
31084 {
31085 arg5 = (int)(SWIG_As_int(obj4));
31086 if (SWIG_arg_fail(5)) SWIG_fail;
31087 }
31088 if (obj5) {
31089 {
31090 arg6 = (bool)(SWIG_As_bool(obj5));
31091 if (SWIG_arg_fail(6)) SWIG_fail;
31092 }
31093 }
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31097
31098 wxPyEndAllowThreads(__tstate);
31099 if (PyErr_Occurred()) SWIG_fail;
31100 }
31101 Py_INCREF(Py_None); resultobj = Py_None;
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31109 PyObject *resultobj;
31110 wxWindow *arg1 = (wxWindow *) 0 ;
31111 int arg2 ;
31112 int arg3 ;
31113 bool arg4 = (bool) true ;
31114 PyObject * obj0 = 0 ;
31115 PyObject * obj1 = 0 ;
31116 PyObject * obj2 = 0 ;
31117 PyObject * obj3 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 arg2 = (int)(SWIG_As_int(obj1));
31127 if (SWIG_arg_fail(2)) SWIG_fail;
31128 }
31129 {
31130 arg3 = (int)(SWIG_As_int(obj2));
31131 if (SWIG_arg_fail(3)) SWIG_fail;
31132 }
31133 if (obj3) {
31134 {
31135 arg4 = (bool)(SWIG_As_bool(obj3));
31136 if (SWIG_arg_fail(4)) SWIG_fail;
31137 }
31138 }
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 (arg1)->SetScrollPos(arg2,arg3,arg4);
31142
31143 wxPyEndAllowThreads(__tstate);
31144 if (PyErr_Occurred()) SWIG_fail;
31145 }
31146 Py_INCREF(Py_None); resultobj = Py_None;
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31154 PyObject *resultobj;
31155 wxWindow *arg1 = (wxWindow *) 0 ;
31156 int arg2 ;
31157 int result;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self",(char *) "orientation", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 {
31168 arg2 = (int)(SWIG_As_int(obj1));
31169 if (SWIG_arg_fail(2)) SWIG_fail;
31170 }
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31174
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 {
31179 resultobj = SWIG_From_int((int)(result));
31180 }
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 int arg2 ;
31191 int result;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "orientation", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = (int)(SWIG_As_int(obj1));
31203 if (SWIG_arg_fail(2)) SWIG_fail;
31204 }
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 {
31213 resultobj = SWIG_From_int((int)(result));
31214 }
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 int arg2 ;
31225 int result;
31226 PyObject * obj0 = 0 ;
31227 PyObject * obj1 = 0 ;
31228 char *kwnames[] = {
31229 (char *) "self",(char *) "orientation", NULL
31230 };
31231
31232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31234 if (SWIG_arg_fail(1)) SWIG_fail;
31235 {
31236 arg2 = (int)(SWIG_As_int(obj1));
31237 if (SWIG_arg_fail(2)) SWIG_fail;
31238 }
31239 {
31240 PyThreadState* __tstate = wxPyBeginAllowThreads();
31241 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31242
31243 wxPyEndAllowThreads(__tstate);
31244 if (PyErr_Occurred()) SWIG_fail;
31245 }
31246 {
31247 resultobj = SWIG_From_int((int)(result));
31248 }
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxWindow *arg1 = (wxWindow *) 0 ;
31258 int arg2 ;
31259 int arg3 ;
31260 wxRect *arg4 = (wxRect *) NULL ;
31261 PyObject * obj0 = 0 ;
31262 PyObject * obj1 = 0 ;
31263 PyObject * obj2 = 0 ;
31264 PyObject * obj3 = 0 ;
31265 char *kwnames[] = {
31266 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31267 };
31268
31269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31271 if (SWIG_arg_fail(1)) SWIG_fail;
31272 {
31273 arg2 = (int)(SWIG_As_int(obj1));
31274 if (SWIG_arg_fail(2)) SWIG_fail;
31275 }
31276 {
31277 arg3 = (int)(SWIG_As_int(obj2));
31278 if (SWIG_arg_fail(3)) SWIG_fail;
31279 }
31280 if (obj3) {
31281 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31282 if (SWIG_arg_fail(4)) SWIG_fail;
31283 }
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31287
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 Py_INCREF(Py_None); resultobj = Py_None;
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31299 PyObject *resultobj;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 int arg2 ;
31302 bool result;
31303 PyObject * obj0 = 0 ;
31304 PyObject * obj1 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self",(char *) "lines", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 {
31313 arg2 = (int)(SWIG_As_int(obj1));
31314 if (SWIG_arg_fail(2)) SWIG_fail;
31315 }
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = (bool)(arg1)->ScrollLines(arg2);
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 int arg2 ;
31336 bool result;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 char *kwnames[] = {
31340 (char *) "self",(char *) "pages", NULL
31341 };
31342
31343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31345 if (SWIG_arg_fail(1)) SWIG_fail;
31346 {
31347 arg2 = (int)(SWIG_As_int(obj1));
31348 if (SWIG_arg_fail(2)) SWIG_fail;
31349 }
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (bool)(arg1)->ScrollPages(arg2);
31353
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 {
31358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31359 }
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 bool result;
31370 PyObject * obj0 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 PyThreadState* __tstate = wxPyBeginAllowThreads();
31380 result = (bool)(arg1)->LineUp();
31381
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 {
31386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31387 }
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31395 PyObject *resultobj;
31396 wxWindow *arg1 = (wxWindow *) 0 ;
31397 bool result;
31398 PyObject * obj0 = 0 ;
31399 char *kwnames[] = {
31400 (char *) "self", NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31405 if (SWIG_arg_fail(1)) SWIG_fail;
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = (bool)(arg1)->LineDown();
31409
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 {
31414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31415 }
31416 return resultobj;
31417 fail:
31418 return NULL;
31419 }
31420
31421
31422 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31423 PyObject *resultobj;
31424 wxWindow *arg1 = (wxWindow *) 0 ;
31425 bool result;
31426 PyObject * obj0 = 0 ;
31427 char *kwnames[] = {
31428 (char *) "self", NULL
31429 };
31430
31431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31433 if (SWIG_arg_fail(1)) SWIG_fail;
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (bool)(arg1)->PageUp();
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 {
31442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 bool result;
31454 PyObject * obj0 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 result = (bool)(arg1)->PageDown();
31465
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 {
31470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31471 }
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31479 PyObject *resultobj;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 wxString *arg2 = 0 ;
31482 bool temp2 = false ;
31483 PyObject * obj0 = 0 ;
31484 PyObject * obj1 = 0 ;
31485 char *kwnames[] = {
31486 (char *) "self",(char *) "text", NULL
31487 };
31488
31489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31491 if (SWIG_arg_fail(1)) SWIG_fail;
31492 {
31493 arg2 = wxString_in_helper(obj1);
31494 if (arg2 == NULL) SWIG_fail;
31495 temp2 = true;
31496 }
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 (arg1)->SetHelpText((wxString const &)*arg2);
31500
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 Py_INCREF(Py_None); resultobj = Py_None;
31505 {
31506 if (temp2)
31507 delete arg2;
31508 }
31509 return resultobj;
31510 fail:
31511 {
31512 if (temp2)
31513 delete arg2;
31514 }
31515 return NULL;
31516 }
31517
31518
31519 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31520 PyObject *resultobj;
31521 wxWindow *arg1 = (wxWindow *) 0 ;
31522 wxString *arg2 = 0 ;
31523 bool temp2 = false ;
31524 PyObject * obj0 = 0 ;
31525 PyObject * obj1 = 0 ;
31526 char *kwnames[] = {
31527 (char *) "self",(char *) "text", NULL
31528 };
31529
31530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31532 if (SWIG_arg_fail(1)) SWIG_fail;
31533 {
31534 arg2 = wxString_in_helper(obj1);
31535 if (arg2 == NULL) SWIG_fail;
31536 temp2 = true;
31537 }
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31541
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 Py_INCREF(Py_None); resultobj = Py_None;
31546 {
31547 if (temp2)
31548 delete arg2;
31549 }
31550 return resultobj;
31551 fail:
31552 {
31553 if (temp2)
31554 delete arg2;
31555 }
31556 return NULL;
31557 }
31558
31559
31560 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31561 PyObject *resultobj;
31562 wxWindow *arg1 = (wxWindow *) 0 ;
31563 wxString result;
31564 PyObject * obj0 = 0 ;
31565 char *kwnames[] = {
31566 (char *) "self", NULL
31567 };
31568
31569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31571 if (SWIG_arg_fail(1)) SWIG_fail;
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = ((wxWindow const *)arg1)->GetHelpText();
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 {
31580 #if wxUSE_UNICODE
31581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31582 #else
31583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31584 #endif
31585 }
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 wxString *arg2 = 0 ;
31596 bool temp2 = false ;
31597 PyObject * obj0 = 0 ;
31598 PyObject * obj1 = 0 ;
31599 char *kwnames[] = {
31600 (char *) "self",(char *) "tip", NULL
31601 };
31602
31603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31605 if (SWIG_arg_fail(1)) SWIG_fail;
31606 {
31607 arg2 = wxString_in_helper(obj1);
31608 if (arg2 == NULL) SWIG_fail;
31609 temp2 = true;
31610 }
31611 {
31612 PyThreadState* __tstate = wxPyBeginAllowThreads();
31613 (arg1)->SetToolTip((wxString const &)*arg2);
31614
31615 wxPyEndAllowThreads(__tstate);
31616 if (PyErr_Occurred()) SWIG_fail;
31617 }
31618 Py_INCREF(Py_None); resultobj = Py_None;
31619 {
31620 if (temp2)
31621 delete arg2;
31622 }
31623 return resultobj;
31624 fail:
31625 {
31626 if (temp2)
31627 delete arg2;
31628 }
31629 return NULL;
31630 }
31631
31632
31633 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31634 PyObject *resultobj;
31635 wxWindow *arg1 = (wxWindow *) 0 ;
31636 wxToolTip *arg2 = (wxToolTip *) 0 ;
31637 PyObject * obj0 = 0 ;
31638 PyObject * obj1 = 0 ;
31639 char *kwnames[] = {
31640 (char *) "self",(char *) "tip", NULL
31641 };
31642
31643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31645 if (SWIG_arg_fail(1)) SWIG_fail;
31646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31647 if (SWIG_arg_fail(2)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 (arg1)->SetToolTip(arg2);
31651
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 Py_INCREF(Py_None); resultobj = Py_None;
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31663 PyObject *resultobj;
31664 wxWindow *arg1 = (wxWindow *) 0 ;
31665 wxToolTip *result;
31666 PyObject * obj0 = 0 ;
31667 char *kwnames[] = {
31668 (char *) "self", NULL
31669 };
31670
31671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31673 if (SWIG_arg_fail(1)) SWIG_fail;
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31677
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 {
31682 resultobj = wxPyMake_wxObject(result, 0);
31683 }
31684 return resultobj;
31685 fail:
31686 return NULL;
31687 }
31688
31689
31690 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31691 PyObject *resultobj;
31692 wxWindow *arg1 = (wxWindow *) 0 ;
31693 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 char *kwnames[] = {
31697 (char *) "self",(char *) "dropTarget", NULL
31698 };
31699
31700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31702 if (SWIG_arg_fail(1)) SWIG_fail;
31703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31704 if (SWIG_arg_fail(2)) SWIG_fail;
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 (arg1)->SetDropTarget(arg2);
31708
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 Py_INCREF(Py_None); resultobj = Py_None;
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31720 PyObject *resultobj;
31721 wxWindow *arg1 = (wxWindow *) 0 ;
31722 wxPyDropTarget *result;
31723 PyObject * obj0 = 0 ;
31724 char *kwnames[] = {
31725 (char *) "self", NULL
31726 };
31727
31728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31730 if (SWIG_arg_fail(1)) SWIG_fail;
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31734
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj;
31747 wxWindow *arg1 = (wxWindow *) 0 ;
31748 bool arg2 ;
31749 PyObject * obj0 = 0 ;
31750 PyObject * obj1 = 0 ;
31751 char *kwnames[] = {
31752 (char *) "self",(char *) "accept", NULL
31753 };
31754
31755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31757 if (SWIG_arg_fail(1)) SWIG_fail;
31758 {
31759 arg2 = (bool)(SWIG_As_bool(obj1));
31760 if (SWIG_arg_fail(2)) SWIG_fail;
31761 }
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 (arg1)->DragAcceptFiles(arg2);
31765
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 Py_INCREF(Py_None); resultobj = Py_None;
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31777 PyObject *resultobj;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31780 PyObject * obj0 = 0 ;
31781 PyObject * obj1 = 0 ;
31782 char *kwnames[] = {
31783 (char *) "self",(char *) "constraints", NULL
31784 };
31785
31786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31788 if (SWIG_arg_fail(1)) SWIG_fail;
31789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31790 if (SWIG_arg_fail(2)) SWIG_fail;
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 (arg1)->SetConstraints(arg2);
31794
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 Py_INCREF(Py_None); resultobj = Py_None;
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj;
31807 wxWindow *arg1 = (wxWindow *) 0 ;
31808 wxLayoutConstraints *result;
31809 PyObject * obj0 = 0 ;
31810 char *kwnames[] = {
31811 (char *) "self", NULL
31812 };
31813
31814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31816 if (SWIG_arg_fail(1)) SWIG_fail;
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31820
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31825 return resultobj;
31826 fail:
31827 return NULL;
31828 }
31829
31830
31831 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31832 PyObject *resultobj;
31833 wxWindow *arg1 = (wxWindow *) 0 ;
31834 bool arg2 ;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 char *kwnames[] = {
31838 (char *) "self",(char *) "autoLayout", NULL
31839 };
31840
31841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31843 if (SWIG_arg_fail(1)) SWIG_fail;
31844 {
31845 arg2 = (bool)(SWIG_As_bool(obj1));
31846 if (SWIG_arg_fail(2)) SWIG_fail;
31847 }
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 (arg1)->SetAutoLayout(arg2);
31851
31852 wxPyEndAllowThreads(__tstate);
31853 if (PyErr_Occurred()) SWIG_fail;
31854 }
31855 Py_INCREF(Py_None); resultobj = Py_None;
31856 return resultobj;
31857 fail:
31858 return NULL;
31859 }
31860
31861
31862 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31863 PyObject *resultobj;
31864 wxWindow *arg1 = (wxWindow *) 0 ;
31865 bool result;
31866 PyObject * obj0 = 0 ;
31867 char *kwnames[] = {
31868 (char *) "self", NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(1)) SWIG_fail;
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31877
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 wxWindow *arg1 = (wxWindow *) 0 ;
31893 bool result;
31894 PyObject * obj0 = 0 ;
31895 char *kwnames[] = {
31896 (char *) "self", NULL
31897 };
31898
31899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31901 if (SWIG_arg_fail(1)) SWIG_fail;
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = (bool)(arg1)->Layout();
31905
31906 wxPyEndAllowThreads(__tstate);
31907 if (PyErr_Occurred()) SWIG_fail;
31908 }
31909 {
31910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31911 }
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj;
31920 wxWindow *arg1 = (wxWindow *) 0 ;
31921 wxSizer *arg2 = (wxSizer *) 0 ;
31922 bool arg3 = (bool) true ;
31923 PyObject * obj0 = 0 ;
31924 PyObject * obj1 = 0 ;
31925 PyObject * obj2 = 0 ;
31926 char *kwnames[] = {
31927 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31928 };
31929
31930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31932 if (SWIG_arg_fail(1)) SWIG_fail;
31933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31934 if (SWIG_arg_fail(2)) SWIG_fail;
31935 if (obj2) {
31936 {
31937 arg3 = (bool)(SWIG_As_bool(obj2));
31938 if (SWIG_arg_fail(3)) SWIG_fail;
31939 }
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 (arg1)->SetSizer(arg2,arg3);
31944
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 Py_INCREF(Py_None); resultobj = Py_None;
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31956 PyObject *resultobj;
31957 wxWindow *arg1 = (wxWindow *) 0 ;
31958 wxSizer *arg2 = (wxSizer *) 0 ;
31959 bool arg3 = (bool) true ;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 PyObject * obj2 = 0 ;
31963 char *kwnames[] = {
31964 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31965 };
31966
31967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31969 if (SWIG_arg_fail(1)) SWIG_fail;
31970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31971 if (SWIG_arg_fail(2)) SWIG_fail;
31972 if (obj2) {
31973 {
31974 arg3 = (bool)(SWIG_As_bool(obj2));
31975 if (SWIG_arg_fail(3)) SWIG_fail;
31976 }
31977 }
31978 {
31979 PyThreadState* __tstate = wxPyBeginAllowThreads();
31980 (arg1)->SetSizerAndFit(arg2,arg3);
31981
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 Py_INCREF(Py_None); resultobj = Py_None;
31986 return resultobj;
31987 fail:
31988 return NULL;
31989 }
31990
31991
31992 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31993 PyObject *resultobj;
31994 wxWindow *arg1 = (wxWindow *) 0 ;
31995 wxSizer *result;
31996 PyObject * obj0 = 0 ;
31997 char *kwnames[] = {
31998 (char *) "self", NULL
31999 };
32000
32001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32003 if (SWIG_arg_fail(1)) SWIG_fail;
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32007
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 {
32012 resultobj = wxPyMake_wxSizer(result, 0);
32013 }
32014 return resultobj;
32015 fail:
32016 return NULL;
32017 }
32018
32019
32020 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32021 PyObject *resultobj;
32022 wxWindow *arg1 = (wxWindow *) 0 ;
32023 wxSizer *arg2 = (wxSizer *) 0 ;
32024 PyObject * obj0 = 0 ;
32025 PyObject * obj1 = 0 ;
32026 char *kwnames[] = {
32027 (char *) "self",(char *) "sizer", NULL
32028 };
32029
32030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32032 if (SWIG_arg_fail(1)) SWIG_fail;
32033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32034 if (SWIG_arg_fail(2)) SWIG_fail;
32035 {
32036 PyThreadState* __tstate = wxPyBeginAllowThreads();
32037 (arg1)->SetContainingSizer(arg2);
32038
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 Py_INCREF(Py_None); resultobj = Py_None;
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 wxSizer *result;
32053 PyObject * obj0 = 0 ;
32054 char *kwnames[] = {
32055 (char *) "self", NULL
32056 };
32057
32058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32060 if (SWIG_arg_fail(1)) SWIG_fail;
32061 {
32062 PyThreadState* __tstate = wxPyBeginAllowThreads();
32063 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32064
32065 wxPyEndAllowThreads(__tstate);
32066 if (PyErr_Occurred()) SWIG_fail;
32067 }
32068 {
32069 resultobj = wxPyMake_wxSizer(result, 0);
32070 }
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32078 PyObject *resultobj;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 PyObject * obj0 = 0 ;
32081 char *kwnames[] = {
32082 (char *) "self", NULL
32083 };
32084
32085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32087 if (SWIG_arg_fail(1)) SWIG_fail;
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 (arg1)->InheritAttributes();
32091
32092 wxPyEndAllowThreads(__tstate);
32093 if (PyErr_Occurred()) SWIG_fail;
32094 }
32095 Py_INCREF(Py_None); resultobj = Py_None;
32096 return resultobj;
32097 fail:
32098 return NULL;
32099 }
32100
32101
32102 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32103 PyObject *resultobj;
32104 wxWindow *arg1 = (wxWindow *) 0 ;
32105 bool result;
32106 PyObject * obj0 = 0 ;
32107 char *kwnames[] = {
32108 (char *) "self", NULL
32109 };
32110
32111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32113 if (SWIG_arg_fail(1)) SWIG_fail;
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32117
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 {
32122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32123 }
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32131 PyObject *obj;
32132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32133 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32134 Py_INCREF(obj);
32135 return Py_BuildValue((char *)"");
32136 }
32137 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32138 PyObject *resultobj;
32139 long arg1 ;
32140 wxWindow *arg2 = (wxWindow *) NULL ;
32141 wxWindow *result;
32142 PyObject * obj0 = 0 ;
32143 PyObject * obj1 = 0 ;
32144 char *kwnames[] = {
32145 (char *) "id",(char *) "parent", NULL
32146 };
32147
32148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32149 {
32150 arg1 = (long)(SWIG_As_long(obj0));
32151 if (SWIG_arg_fail(1)) SWIG_fail;
32152 }
32153 if (obj1) {
32154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32155 if (SWIG_arg_fail(2)) SWIG_fail;
32156 }
32157 {
32158 if (!wxPyCheckForApp()) SWIG_fail;
32159 PyThreadState* __tstate = wxPyBeginAllowThreads();
32160 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32161
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 {
32166 resultobj = wxPyMake_wxObject(result, 0);
32167 }
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32175 PyObject *resultobj;
32176 wxString *arg1 = 0 ;
32177 wxWindow *arg2 = (wxWindow *) NULL ;
32178 wxWindow *result;
32179 bool temp1 = false ;
32180 PyObject * obj0 = 0 ;
32181 PyObject * obj1 = 0 ;
32182 char *kwnames[] = {
32183 (char *) "name",(char *) "parent", NULL
32184 };
32185
32186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32187 {
32188 arg1 = wxString_in_helper(obj0);
32189 if (arg1 == NULL) SWIG_fail;
32190 temp1 = true;
32191 }
32192 if (obj1) {
32193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32194 if (SWIG_arg_fail(2)) SWIG_fail;
32195 }
32196 {
32197 if (!wxPyCheckForApp()) SWIG_fail;
32198 PyThreadState* __tstate = wxPyBeginAllowThreads();
32199 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32200
32201 wxPyEndAllowThreads(__tstate);
32202 if (PyErr_Occurred()) SWIG_fail;
32203 }
32204 {
32205 resultobj = wxPyMake_wxObject(result, 0);
32206 }
32207 {
32208 if (temp1)
32209 delete arg1;
32210 }
32211 return resultobj;
32212 fail:
32213 {
32214 if (temp1)
32215 delete arg1;
32216 }
32217 return NULL;
32218 }
32219
32220
32221 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32222 PyObject *resultobj;
32223 wxString *arg1 = 0 ;
32224 wxWindow *arg2 = (wxWindow *) NULL ;
32225 wxWindow *result;
32226 bool temp1 = false ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char *kwnames[] = {
32230 (char *) "label",(char *) "parent", NULL
32231 };
32232
32233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32234 {
32235 arg1 = wxString_in_helper(obj0);
32236 if (arg1 == NULL) SWIG_fail;
32237 temp1 = true;
32238 }
32239 if (obj1) {
32240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32241 if (SWIG_arg_fail(2)) SWIG_fail;
32242 }
32243 {
32244 if (!wxPyCheckForApp()) SWIG_fail;
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32247
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = wxPyMake_wxObject(result, 0);
32253 }
32254 {
32255 if (temp1)
32256 delete arg1;
32257 }
32258 return resultobj;
32259 fail:
32260 {
32261 if (temp1)
32262 delete arg1;
32263 }
32264 return NULL;
32265 }
32266
32267
32268 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32269 PyObject *resultobj;
32270 wxWindow *arg1 = (wxWindow *) 0 ;
32271 unsigned long arg2 ;
32272 wxWindow *result;
32273 PyObject * obj0 = 0 ;
32274 PyObject * obj1 = 0 ;
32275 char *kwnames[] = {
32276 (char *) "parent",(char *) "_hWnd", NULL
32277 };
32278
32279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32281 if (SWIG_arg_fail(1)) SWIG_fail;
32282 {
32283 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32284 if (SWIG_arg_fail(2)) SWIG_fail;
32285 }
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32289
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 {
32294 resultobj = wxPyMake_wxObject(result, 0);
32295 }
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj;
32304 PyObject *result;
32305 char *kwnames[] = {
32306 NULL
32307 };
32308
32309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (PyObject *)GetTopLevelWindows();
32313
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 resultobj = result;
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32325 PyObject *resultobj;
32326 wxValidator *result;
32327 char *kwnames[] = {
32328 NULL
32329 };
32330
32331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 result = (wxValidator *)new wxValidator();
32335
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32340 return resultobj;
32341 fail:
32342 return NULL;
32343 }
32344
32345
32346 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32347 PyObject *resultobj;
32348 wxValidator *arg1 = (wxValidator *) 0 ;
32349 wxValidator *result;
32350 PyObject * obj0 = 0 ;
32351 char *kwnames[] = {
32352 (char *) "self", NULL
32353 };
32354
32355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32357 if (SWIG_arg_fail(1)) SWIG_fail;
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 result = (wxValidator *)(arg1)->Clone();
32361
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 {
32366 resultobj = wxPyMake_wxObject(result, 0);
32367 }
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj;
32376 wxValidator *arg1 = (wxValidator *) 0 ;
32377 wxWindow *arg2 = (wxWindow *) 0 ;
32378 bool result;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 char *kwnames[] = {
32382 (char *) "self",(char *) "parent", NULL
32383 };
32384
32385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32387 if (SWIG_arg_fail(1)) SWIG_fail;
32388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32389 if (SWIG_arg_fail(2)) SWIG_fail;
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 result = (bool)(arg1)->Validate(arg2);
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 {
32398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32399 }
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32407 PyObject *resultobj;
32408 wxValidator *arg1 = (wxValidator *) 0 ;
32409 bool result;
32410 PyObject * obj0 = 0 ;
32411 char *kwnames[] = {
32412 (char *) "self", NULL
32413 };
32414
32415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32417 if (SWIG_arg_fail(1)) SWIG_fail;
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (bool)(arg1)->TransferToWindow();
32421
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 {
32426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32427 }
32428 return resultobj;
32429 fail:
32430 return NULL;
32431 }
32432
32433
32434 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32435 PyObject *resultobj;
32436 wxValidator *arg1 = (wxValidator *) 0 ;
32437 bool result;
32438 PyObject * obj0 = 0 ;
32439 char *kwnames[] = {
32440 (char *) "self", NULL
32441 };
32442
32443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32445 if (SWIG_arg_fail(1)) SWIG_fail;
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (bool)(arg1)->TransferFromWindow();
32449
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 {
32454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32455 }
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj;
32464 wxValidator *arg1 = (wxValidator *) 0 ;
32465 wxWindow *result;
32466 PyObject * obj0 = 0 ;
32467 char *kwnames[] = {
32468 (char *) "self", NULL
32469 };
32470
32471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32473 if (SWIG_arg_fail(1)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = (wxWindow *)(arg1)->GetWindow();
32477
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 {
32482 resultobj = wxPyMake_wxObject(result, 0);
32483 }
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32491 PyObject *resultobj;
32492 wxValidator *arg1 = (wxValidator *) 0 ;
32493 wxWindow *arg2 = (wxWindow *) 0 ;
32494 PyObject * obj0 = 0 ;
32495 PyObject * obj1 = 0 ;
32496 char *kwnames[] = {
32497 (char *) "self",(char *) "window", NULL
32498 };
32499
32500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32502 if (SWIG_arg_fail(1)) SWIG_fail;
32503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32504 if (SWIG_arg_fail(2)) SWIG_fail;
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 (arg1)->SetWindow(arg2);
32508
32509 wxPyEndAllowThreads(__tstate);
32510 if (PyErr_Occurred()) SWIG_fail;
32511 }
32512 Py_INCREF(Py_None); resultobj = Py_None;
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj;
32521 bool result;
32522 char *kwnames[] = {
32523 NULL
32524 };
32525
32526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = (bool)wxValidator::IsSilent();
32530
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 {
32535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32536 }
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj;
32545 int arg1 = (int) true ;
32546 PyObject * obj0 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "doIt", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32552 if (obj0) {
32553 {
32554 arg1 = (int)(SWIG_As_int(obj0));
32555 if (SWIG_arg_fail(1)) SWIG_fail;
32556 }
32557 }
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 wxValidator::SetBellOnError(arg1);
32561
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 Py_INCREF(Py_None); resultobj = Py_None;
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32573 PyObject *obj;
32574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32575 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32576 Py_INCREF(obj);
32577 return Py_BuildValue((char *)"");
32578 }
32579 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32580 PyObject *resultobj;
32581 wxPyValidator *result;
32582 char *kwnames[] = {
32583 NULL
32584 };
32585
32586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 result = (wxPyValidator *)new wxPyValidator();
32590
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj;
32603 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32604 PyObject *arg2 = (PyObject *) 0 ;
32605 PyObject *arg3 = (PyObject *) 0 ;
32606 int arg4 = (int) true ;
32607 PyObject * obj0 = 0 ;
32608 PyObject * obj1 = 0 ;
32609 PyObject * obj2 = 0 ;
32610 PyObject * obj3 = 0 ;
32611 char *kwnames[] = {
32612 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32613 };
32614
32615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32617 if (SWIG_arg_fail(1)) SWIG_fail;
32618 arg2 = obj1;
32619 arg3 = obj2;
32620 if (obj3) {
32621 {
32622 arg4 = (int)(SWIG_As_int(obj3));
32623 if (SWIG_arg_fail(4)) SWIG_fail;
32624 }
32625 }
32626 {
32627 PyThreadState* __tstate = wxPyBeginAllowThreads();
32628 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32629
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 Py_INCREF(Py_None); resultobj = Py_None;
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32641 PyObject *obj;
32642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32643 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32644 Py_INCREF(obj);
32645 return Py_BuildValue((char *)"");
32646 }
32647 static int _wrap_DefaultValidator_set(PyObject *) {
32648 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32649 return 1;
32650 }
32651
32652
32653 static PyObject *_wrap_DefaultValidator_get(void) {
32654 PyObject *pyobj;
32655
32656 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32657 return pyobj;
32658 }
32659
32660
32661 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj;
32663 wxString const &arg1_defvalue = wxPyEmptyString ;
32664 wxString *arg1 = (wxString *) &arg1_defvalue ;
32665 long arg2 = (long) 0 ;
32666 wxMenu *result;
32667 bool temp1 = false ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 char *kwnames[] = {
32671 (char *) "title",(char *) "style", NULL
32672 };
32673
32674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32675 if (obj0) {
32676 {
32677 arg1 = wxString_in_helper(obj0);
32678 if (arg1 == NULL) SWIG_fail;
32679 temp1 = true;
32680 }
32681 }
32682 if (obj1) {
32683 {
32684 arg2 = (long)(SWIG_As_long(obj1));
32685 if (SWIG_arg_fail(2)) SWIG_fail;
32686 }
32687 }
32688 {
32689 if (!wxPyCheckForApp()) SWIG_fail;
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32692
32693 wxPyEndAllowThreads(__tstate);
32694 if (PyErr_Occurred()) SWIG_fail;
32695 }
32696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32697 {
32698 if (temp1)
32699 delete arg1;
32700 }
32701 return resultobj;
32702 fail:
32703 {
32704 if (temp1)
32705 delete arg1;
32706 }
32707 return NULL;
32708 }
32709
32710
32711 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32712 PyObject *resultobj;
32713 wxMenu *arg1 = (wxMenu *) 0 ;
32714 int arg2 ;
32715 wxString *arg3 = 0 ;
32716 wxString const &arg4_defvalue = wxPyEmptyString ;
32717 wxString *arg4 = (wxString *) &arg4_defvalue ;
32718 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32719 wxMenuItem *result;
32720 bool temp3 = false ;
32721 bool temp4 = false ;
32722 PyObject * obj0 = 0 ;
32723 PyObject * obj1 = 0 ;
32724 PyObject * obj2 = 0 ;
32725 PyObject * obj3 = 0 ;
32726 PyObject * obj4 = 0 ;
32727 char *kwnames[] = {
32728 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32729 };
32730
32731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32733 if (SWIG_arg_fail(1)) SWIG_fail;
32734 {
32735 arg2 = (int)(SWIG_As_int(obj1));
32736 if (SWIG_arg_fail(2)) SWIG_fail;
32737 }
32738 {
32739 arg3 = wxString_in_helper(obj2);
32740 if (arg3 == NULL) SWIG_fail;
32741 temp3 = true;
32742 }
32743 if (obj3) {
32744 {
32745 arg4 = wxString_in_helper(obj3);
32746 if (arg4 == NULL) SWIG_fail;
32747 temp4 = true;
32748 }
32749 }
32750 if (obj4) {
32751 {
32752 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32753 if (SWIG_arg_fail(5)) SWIG_fail;
32754 }
32755 }
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32759
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 {
32764 resultobj = wxPyMake_wxObject(result, 0);
32765 }
32766 {
32767 if (temp3)
32768 delete arg3;
32769 }
32770 {
32771 if (temp4)
32772 delete arg4;
32773 }
32774 return resultobj;
32775 fail:
32776 {
32777 if (temp3)
32778 delete arg3;
32779 }
32780 {
32781 if (temp4)
32782 delete arg4;
32783 }
32784 return NULL;
32785 }
32786
32787
32788 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj;
32790 wxMenu *arg1 = (wxMenu *) 0 ;
32791 wxMenuItem *result;
32792 PyObject * obj0 = 0 ;
32793 char *kwnames[] = {
32794 (char *) "self", NULL
32795 };
32796
32797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32799 if (SWIG_arg_fail(1)) SWIG_fail;
32800 {
32801 PyThreadState* __tstate = wxPyBeginAllowThreads();
32802 result = (wxMenuItem *)(arg1)->AppendSeparator();
32803
32804 wxPyEndAllowThreads(__tstate);
32805 if (PyErr_Occurred()) SWIG_fail;
32806 }
32807 {
32808 resultobj = wxPyMake_wxObject(result, 0);
32809 }
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32817 PyObject *resultobj;
32818 wxMenu *arg1 = (wxMenu *) 0 ;
32819 int arg2 ;
32820 wxString *arg3 = 0 ;
32821 wxString const &arg4_defvalue = wxPyEmptyString ;
32822 wxString *arg4 = (wxString *) &arg4_defvalue ;
32823 wxMenuItem *result;
32824 bool temp3 = false ;
32825 bool temp4 = false ;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 PyObject * obj2 = 0 ;
32829 PyObject * obj3 = 0 ;
32830 char *kwnames[] = {
32831 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32832 };
32833
32834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32836 if (SWIG_arg_fail(1)) SWIG_fail;
32837 {
32838 arg2 = (int)(SWIG_As_int(obj1));
32839 if (SWIG_arg_fail(2)) SWIG_fail;
32840 }
32841 {
32842 arg3 = wxString_in_helper(obj2);
32843 if (arg3 == NULL) SWIG_fail;
32844 temp3 = true;
32845 }
32846 if (obj3) {
32847 {
32848 arg4 = wxString_in_helper(obj3);
32849 if (arg4 == NULL) SWIG_fail;
32850 temp4 = true;
32851 }
32852 }
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32856
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 {
32861 resultobj = wxPyMake_wxObject(result, 0);
32862 }
32863 {
32864 if (temp3)
32865 delete arg3;
32866 }
32867 {
32868 if (temp4)
32869 delete arg4;
32870 }
32871 return resultobj;
32872 fail:
32873 {
32874 if (temp3)
32875 delete arg3;
32876 }
32877 {
32878 if (temp4)
32879 delete arg4;
32880 }
32881 return NULL;
32882 }
32883
32884
32885 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32886 PyObject *resultobj;
32887 wxMenu *arg1 = (wxMenu *) 0 ;
32888 int arg2 ;
32889 wxString *arg3 = 0 ;
32890 wxString const &arg4_defvalue = wxPyEmptyString ;
32891 wxString *arg4 = (wxString *) &arg4_defvalue ;
32892 wxMenuItem *result;
32893 bool temp3 = false ;
32894 bool temp4 = false ;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 PyObject * obj2 = 0 ;
32898 PyObject * obj3 = 0 ;
32899 char *kwnames[] = {
32900 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32901 };
32902
32903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32905 if (SWIG_arg_fail(1)) SWIG_fail;
32906 {
32907 arg2 = (int)(SWIG_As_int(obj1));
32908 if (SWIG_arg_fail(2)) SWIG_fail;
32909 }
32910 {
32911 arg3 = wxString_in_helper(obj2);
32912 if (arg3 == NULL) SWIG_fail;
32913 temp3 = true;
32914 }
32915 if (obj3) {
32916 {
32917 arg4 = wxString_in_helper(obj3);
32918 if (arg4 == NULL) SWIG_fail;
32919 temp4 = true;
32920 }
32921 }
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32925
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 {
32930 resultobj = wxPyMake_wxObject(result, 0);
32931 }
32932 {
32933 if (temp3)
32934 delete arg3;
32935 }
32936 {
32937 if (temp4)
32938 delete arg4;
32939 }
32940 return resultobj;
32941 fail:
32942 {
32943 if (temp3)
32944 delete arg3;
32945 }
32946 {
32947 if (temp4)
32948 delete arg4;
32949 }
32950 return NULL;
32951 }
32952
32953
32954 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32955 PyObject *resultobj;
32956 wxMenu *arg1 = (wxMenu *) 0 ;
32957 int arg2 ;
32958 wxString *arg3 = 0 ;
32959 wxMenu *arg4 = (wxMenu *) 0 ;
32960 wxString const &arg5_defvalue = wxPyEmptyString ;
32961 wxString *arg5 = (wxString *) &arg5_defvalue ;
32962 wxMenuItem *result;
32963 bool temp3 = false ;
32964 bool temp5 = false ;
32965 PyObject * obj0 = 0 ;
32966 PyObject * obj1 = 0 ;
32967 PyObject * obj2 = 0 ;
32968 PyObject * obj3 = 0 ;
32969 PyObject * obj4 = 0 ;
32970 char *kwnames[] = {
32971 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32972 };
32973
32974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32976 if (SWIG_arg_fail(1)) SWIG_fail;
32977 {
32978 arg2 = (int)(SWIG_As_int(obj1));
32979 if (SWIG_arg_fail(2)) SWIG_fail;
32980 }
32981 {
32982 arg3 = wxString_in_helper(obj2);
32983 if (arg3 == NULL) SWIG_fail;
32984 temp3 = true;
32985 }
32986 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32987 if (SWIG_arg_fail(4)) SWIG_fail;
32988 if (obj4) {
32989 {
32990 arg5 = wxString_in_helper(obj4);
32991 if (arg5 == NULL) SWIG_fail;
32992 temp5 = true;
32993 }
32994 }
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32998
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = wxPyMake_wxObject(result, 0);
33004 }
33005 {
33006 if (temp3)
33007 delete arg3;
33008 }
33009 {
33010 if (temp5)
33011 delete arg5;
33012 }
33013 return resultobj;
33014 fail:
33015 {
33016 if (temp3)
33017 delete arg3;
33018 }
33019 {
33020 if (temp5)
33021 delete arg5;
33022 }
33023 return NULL;
33024 }
33025
33026
33027 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj;
33029 wxMenu *arg1 = (wxMenu *) 0 ;
33030 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33031 wxMenuItem *result;
33032 PyObject * obj0 = 0 ;
33033 PyObject * obj1 = 0 ;
33034 char *kwnames[] = {
33035 (char *) "self",(char *) "item", NULL
33036 };
33037
33038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33040 if (SWIG_arg_fail(1)) SWIG_fail;
33041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33042 if (SWIG_arg_fail(2)) SWIG_fail;
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 result = (wxMenuItem *)(arg1)->Append(arg2);
33046
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 {
33051 resultobj = wxPyMake_wxObject(result, 0);
33052 }
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj;
33061 wxMenu *arg1 = (wxMenu *) 0 ;
33062 PyObject * obj0 = 0 ;
33063 char *kwnames[] = {
33064 (char *) "self", NULL
33065 };
33066
33067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33069 if (SWIG_arg_fail(1)) SWIG_fail;
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 (arg1)->Break();
33073
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 Py_INCREF(Py_None); resultobj = Py_None;
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj;
33086 wxMenu *arg1 = (wxMenu *) 0 ;
33087 size_t arg2 ;
33088 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33089 wxMenuItem *result;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 PyObject * obj2 = 0 ;
33093 char *kwnames[] = {
33094 (char *) "self",(char *) "pos",(char *) "item", NULL
33095 };
33096
33097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33099 if (SWIG_arg_fail(1)) SWIG_fail;
33100 {
33101 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33102 if (SWIG_arg_fail(2)) SWIG_fail;
33103 }
33104 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33105 if (SWIG_arg_fail(3)) SWIG_fail;
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33109
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = wxPyMake_wxObject(result, 0);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33123 PyObject *resultobj;
33124 wxMenu *arg1 = (wxMenu *) 0 ;
33125 size_t arg2 ;
33126 int arg3 ;
33127 wxString *arg4 = 0 ;
33128 wxString const &arg5_defvalue = wxPyEmptyString ;
33129 wxString *arg5 = (wxString *) &arg5_defvalue ;
33130 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33131 wxMenuItem *result;
33132 bool temp4 = false ;
33133 bool temp5 = false ;
33134 PyObject * obj0 = 0 ;
33135 PyObject * obj1 = 0 ;
33136 PyObject * obj2 = 0 ;
33137 PyObject * obj3 = 0 ;
33138 PyObject * obj4 = 0 ;
33139 PyObject * obj5 = 0 ;
33140 char *kwnames[] = {
33141 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33142 };
33143
33144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33146 if (SWIG_arg_fail(1)) SWIG_fail;
33147 {
33148 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33149 if (SWIG_arg_fail(2)) SWIG_fail;
33150 }
33151 {
33152 arg3 = (int)(SWIG_As_int(obj2));
33153 if (SWIG_arg_fail(3)) SWIG_fail;
33154 }
33155 {
33156 arg4 = wxString_in_helper(obj3);
33157 if (arg4 == NULL) SWIG_fail;
33158 temp4 = true;
33159 }
33160 if (obj4) {
33161 {
33162 arg5 = wxString_in_helper(obj4);
33163 if (arg5 == NULL) SWIG_fail;
33164 temp5 = true;
33165 }
33166 }
33167 if (obj5) {
33168 {
33169 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33170 if (SWIG_arg_fail(6)) SWIG_fail;
33171 }
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33176
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 {
33181 resultobj = wxPyMake_wxObject(result, 0);
33182 }
33183 {
33184 if (temp4)
33185 delete arg4;
33186 }
33187 {
33188 if (temp5)
33189 delete arg5;
33190 }
33191 return resultobj;
33192 fail:
33193 {
33194 if (temp4)
33195 delete arg4;
33196 }
33197 {
33198 if (temp5)
33199 delete arg5;
33200 }
33201 return NULL;
33202 }
33203
33204
33205 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj;
33207 wxMenu *arg1 = (wxMenu *) 0 ;
33208 size_t arg2 ;
33209 wxMenuItem *result;
33210 PyObject * obj0 = 0 ;
33211 PyObject * obj1 = 0 ;
33212 char *kwnames[] = {
33213 (char *) "self",(char *) "pos", NULL
33214 };
33215
33216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33218 if (SWIG_arg_fail(1)) SWIG_fail;
33219 {
33220 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33221 if (SWIG_arg_fail(2)) SWIG_fail;
33222 }
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33226
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 {
33231 resultobj = wxPyMake_wxObject(result, 0);
33232 }
33233 return resultobj;
33234 fail:
33235 return NULL;
33236 }
33237
33238
33239 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj;
33241 wxMenu *arg1 = (wxMenu *) 0 ;
33242 size_t arg2 ;
33243 int arg3 ;
33244 wxString *arg4 = 0 ;
33245 wxString const &arg5_defvalue = wxPyEmptyString ;
33246 wxString *arg5 = (wxString *) &arg5_defvalue ;
33247 wxMenuItem *result;
33248 bool temp4 = false ;
33249 bool temp5 = false ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 PyObject * obj2 = 0 ;
33253 PyObject * obj3 = 0 ;
33254 PyObject * obj4 = 0 ;
33255 char *kwnames[] = {
33256 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33257 };
33258
33259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33261 if (SWIG_arg_fail(1)) SWIG_fail;
33262 {
33263 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33264 if (SWIG_arg_fail(2)) SWIG_fail;
33265 }
33266 {
33267 arg3 = (int)(SWIG_As_int(obj2));
33268 if (SWIG_arg_fail(3)) SWIG_fail;
33269 }
33270 {
33271 arg4 = wxString_in_helper(obj3);
33272 if (arg4 == NULL) SWIG_fail;
33273 temp4 = true;
33274 }
33275 if (obj4) {
33276 {
33277 arg5 = wxString_in_helper(obj4);
33278 if (arg5 == NULL) SWIG_fail;
33279 temp5 = true;
33280 }
33281 }
33282 {
33283 PyThreadState* __tstate = wxPyBeginAllowThreads();
33284 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33285
33286 wxPyEndAllowThreads(__tstate);
33287 if (PyErr_Occurred()) SWIG_fail;
33288 }
33289 {
33290 resultobj = wxPyMake_wxObject(result, 0);
33291 }
33292 {
33293 if (temp4)
33294 delete arg4;
33295 }
33296 {
33297 if (temp5)
33298 delete arg5;
33299 }
33300 return resultobj;
33301 fail:
33302 {
33303 if (temp4)
33304 delete arg4;
33305 }
33306 {
33307 if (temp5)
33308 delete arg5;
33309 }
33310 return NULL;
33311 }
33312
33313
33314 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33315 PyObject *resultobj;
33316 wxMenu *arg1 = (wxMenu *) 0 ;
33317 size_t arg2 ;
33318 int arg3 ;
33319 wxString *arg4 = 0 ;
33320 wxString const &arg5_defvalue = wxPyEmptyString ;
33321 wxString *arg5 = (wxString *) &arg5_defvalue ;
33322 wxMenuItem *result;
33323 bool temp4 = false ;
33324 bool temp5 = false ;
33325 PyObject * obj0 = 0 ;
33326 PyObject * obj1 = 0 ;
33327 PyObject * obj2 = 0 ;
33328 PyObject * obj3 = 0 ;
33329 PyObject * obj4 = 0 ;
33330 char *kwnames[] = {
33331 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33332 };
33333
33334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33336 if (SWIG_arg_fail(1)) SWIG_fail;
33337 {
33338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33339 if (SWIG_arg_fail(2)) SWIG_fail;
33340 }
33341 {
33342 arg3 = (int)(SWIG_As_int(obj2));
33343 if (SWIG_arg_fail(3)) SWIG_fail;
33344 }
33345 {
33346 arg4 = wxString_in_helper(obj3);
33347 if (arg4 == NULL) SWIG_fail;
33348 temp4 = true;
33349 }
33350 if (obj4) {
33351 {
33352 arg5 = wxString_in_helper(obj4);
33353 if (arg5 == NULL) SWIG_fail;
33354 temp5 = true;
33355 }
33356 }
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33360
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 {
33365 resultobj = wxPyMake_wxObject(result, 0);
33366 }
33367 {
33368 if (temp4)
33369 delete arg4;
33370 }
33371 {
33372 if (temp5)
33373 delete arg5;
33374 }
33375 return resultobj;
33376 fail:
33377 {
33378 if (temp4)
33379 delete arg4;
33380 }
33381 {
33382 if (temp5)
33383 delete arg5;
33384 }
33385 return NULL;
33386 }
33387
33388
33389 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33390 PyObject *resultobj;
33391 wxMenu *arg1 = (wxMenu *) 0 ;
33392 size_t arg2 ;
33393 int arg3 ;
33394 wxString *arg4 = 0 ;
33395 wxMenu *arg5 = (wxMenu *) 0 ;
33396 wxString const &arg6_defvalue = wxPyEmptyString ;
33397 wxString *arg6 = (wxString *) &arg6_defvalue ;
33398 wxMenuItem *result;
33399 bool temp4 = false ;
33400 bool temp6 = false ;
33401 PyObject * obj0 = 0 ;
33402 PyObject * obj1 = 0 ;
33403 PyObject * obj2 = 0 ;
33404 PyObject * obj3 = 0 ;
33405 PyObject * obj4 = 0 ;
33406 PyObject * obj5 = 0 ;
33407 char *kwnames[] = {
33408 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33409 };
33410
33411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33413 if (SWIG_arg_fail(1)) SWIG_fail;
33414 {
33415 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33416 if (SWIG_arg_fail(2)) SWIG_fail;
33417 }
33418 {
33419 arg3 = (int)(SWIG_As_int(obj2));
33420 if (SWIG_arg_fail(3)) SWIG_fail;
33421 }
33422 {
33423 arg4 = wxString_in_helper(obj3);
33424 if (arg4 == NULL) SWIG_fail;
33425 temp4 = true;
33426 }
33427 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(5)) SWIG_fail;
33429 if (obj5) {
33430 {
33431 arg6 = wxString_in_helper(obj5);
33432 if (arg6 == NULL) SWIG_fail;
33433 temp6 = true;
33434 }
33435 }
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33439
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 {
33444 resultobj = wxPyMake_wxObject(result, 0);
33445 }
33446 {
33447 if (temp4)
33448 delete arg4;
33449 }
33450 {
33451 if (temp6)
33452 delete arg6;
33453 }
33454 return resultobj;
33455 fail:
33456 {
33457 if (temp4)
33458 delete arg4;
33459 }
33460 {
33461 if (temp6)
33462 delete arg6;
33463 }
33464 return NULL;
33465 }
33466
33467
33468 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33469 PyObject *resultobj;
33470 wxMenu *arg1 = (wxMenu *) 0 ;
33471 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33472 wxMenuItem *result;
33473 PyObject * obj0 = 0 ;
33474 PyObject * obj1 = 0 ;
33475 char *kwnames[] = {
33476 (char *) "self",(char *) "item", NULL
33477 };
33478
33479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33481 if (SWIG_arg_fail(1)) SWIG_fail;
33482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33483 if (SWIG_arg_fail(2)) SWIG_fail;
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33487
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 {
33492 resultobj = wxPyMake_wxObject(result, 0);
33493 }
33494 return resultobj;
33495 fail:
33496 return NULL;
33497 }
33498
33499
33500 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33501 PyObject *resultobj;
33502 wxMenu *arg1 = (wxMenu *) 0 ;
33503 int arg2 ;
33504 wxString *arg3 = 0 ;
33505 wxString const &arg4_defvalue = wxPyEmptyString ;
33506 wxString *arg4 = (wxString *) &arg4_defvalue ;
33507 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33508 wxMenuItem *result;
33509 bool temp3 = false ;
33510 bool temp4 = false ;
33511 PyObject * obj0 = 0 ;
33512 PyObject * obj1 = 0 ;
33513 PyObject * obj2 = 0 ;
33514 PyObject * obj3 = 0 ;
33515 PyObject * obj4 = 0 ;
33516 char *kwnames[] = {
33517 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33518 };
33519
33520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33522 if (SWIG_arg_fail(1)) SWIG_fail;
33523 {
33524 arg2 = (int)(SWIG_As_int(obj1));
33525 if (SWIG_arg_fail(2)) SWIG_fail;
33526 }
33527 {
33528 arg3 = wxString_in_helper(obj2);
33529 if (arg3 == NULL) SWIG_fail;
33530 temp3 = true;
33531 }
33532 if (obj3) {
33533 {
33534 arg4 = wxString_in_helper(obj3);
33535 if (arg4 == NULL) SWIG_fail;
33536 temp4 = true;
33537 }
33538 }
33539 if (obj4) {
33540 {
33541 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33542 if (SWIG_arg_fail(5)) SWIG_fail;
33543 }
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33548
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 {
33553 resultobj = wxPyMake_wxObject(result, 0);
33554 }
33555 {
33556 if (temp3)
33557 delete arg3;
33558 }
33559 {
33560 if (temp4)
33561 delete arg4;
33562 }
33563 return resultobj;
33564 fail:
33565 {
33566 if (temp3)
33567 delete arg3;
33568 }
33569 {
33570 if (temp4)
33571 delete arg4;
33572 }
33573 return NULL;
33574 }
33575
33576
33577 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj;
33579 wxMenu *arg1 = (wxMenu *) 0 ;
33580 wxMenuItem *result;
33581 PyObject * obj0 = 0 ;
33582 char *kwnames[] = {
33583 (char *) "self", NULL
33584 };
33585
33586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33588 if (SWIG_arg_fail(1)) SWIG_fail;
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (wxMenuItem *)(arg1)->PrependSeparator();
33592
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 {
33597 resultobj = wxPyMake_wxObject(result, 0);
33598 }
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj;
33607 wxMenu *arg1 = (wxMenu *) 0 ;
33608 int arg2 ;
33609 wxString *arg3 = 0 ;
33610 wxString const &arg4_defvalue = wxPyEmptyString ;
33611 wxString *arg4 = (wxString *) &arg4_defvalue ;
33612 wxMenuItem *result;
33613 bool temp3 = false ;
33614 bool temp4 = false ;
33615 PyObject * obj0 = 0 ;
33616 PyObject * obj1 = 0 ;
33617 PyObject * obj2 = 0 ;
33618 PyObject * obj3 = 0 ;
33619 char *kwnames[] = {
33620 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33621 };
33622
33623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33625 if (SWIG_arg_fail(1)) SWIG_fail;
33626 {
33627 arg2 = (int)(SWIG_As_int(obj1));
33628 if (SWIG_arg_fail(2)) SWIG_fail;
33629 }
33630 {
33631 arg3 = wxString_in_helper(obj2);
33632 if (arg3 == NULL) SWIG_fail;
33633 temp3 = true;
33634 }
33635 if (obj3) {
33636 {
33637 arg4 = wxString_in_helper(obj3);
33638 if (arg4 == NULL) SWIG_fail;
33639 temp4 = true;
33640 }
33641 }
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33645
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = wxPyMake_wxObject(result, 0);
33651 }
33652 {
33653 if (temp3)
33654 delete arg3;
33655 }
33656 {
33657 if (temp4)
33658 delete arg4;
33659 }
33660 return resultobj;
33661 fail:
33662 {
33663 if (temp3)
33664 delete arg3;
33665 }
33666 {
33667 if (temp4)
33668 delete arg4;
33669 }
33670 return NULL;
33671 }
33672
33673
33674 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj;
33676 wxMenu *arg1 = (wxMenu *) 0 ;
33677 int arg2 ;
33678 wxString *arg3 = 0 ;
33679 wxString const &arg4_defvalue = wxPyEmptyString ;
33680 wxString *arg4 = (wxString *) &arg4_defvalue ;
33681 wxMenuItem *result;
33682 bool temp3 = false ;
33683 bool temp4 = false ;
33684 PyObject * obj0 = 0 ;
33685 PyObject * obj1 = 0 ;
33686 PyObject * obj2 = 0 ;
33687 PyObject * obj3 = 0 ;
33688 char *kwnames[] = {
33689 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33690 };
33691
33692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33694 if (SWIG_arg_fail(1)) SWIG_fail;
33695 {
33696 arg2 = (int)(SWIG_As_int(obj1));
33697 if (SWIG_arg_fail(2)) SWIG_fail;
33698 }
33699 {
33700 arg3 = wxString_in_helper(obj2);
33701 if (arg3 == NULL) SWIG_fail;
33702 temp3 = true;
33703 }
33704 if (obj3) {
33705 {
33706 arg4 = wxString_in_helper(obj3);
33707 if (arg4 == NULL) SWIG_fail;
33708 temp4 = true;
33709 }
33710 }
33711 {
33712 PyThreadState* __tstate = wxPyBeginAllowThreads();
33713 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33714
33715 wxPyEndAllowThreads(__tstate);
33716 if (PyErr_Occurred()) SWIG_fail;
33717 }
33718 {
33719 resultobj = wxPyMake_wxObject(result, 0);
33720 }
33721 {
33722 if (temp3)
33723 delete arg3;
33724 }
33725 {
33726 if (temp4)
33727 delete arg4;
33728 }
33729 return resultobj;
33730 fail:
33731 {
33732 if (temp3)
33733 delete arg3;
33734 }
33735 {
33736 if (temp4)
33737 delete arg4;
33738 }
33739 return NULL;
33740 }
33741
33742
33743 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33744 PyObject *resultobj;
33745 wxMenu *arg1 = (wxMenu *) 0 ;
33746 int arg2 ;
33747 wxString *arg3 = 0 ;
33748 wxMenu *arg4 = (wxMenu *) 0 ;
33749 wxString const &arg5_defvalue = wxPyEmptyString ;
33750 wxString *arg5 = (wxString *) &arg5_defvalue ;
33751 wxMenuItem *result;
33752 bool temp3 = false ;
33753 bool temp5 = false ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 PyObject * obj2 = 0 ;
33757 PyObject * obj3 = 0 ;
33758 PyObject * obj4 = 0 ;
33759 char *kwnames[] = {
33760 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33761 };
33762
33763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33765 if (SWIG_arg_fail(1)) SWIG_fail;
33766 {
33767 arg2 = (int)(SWIG_As_int(obj1));
33768 if (SWIG_arg_fail(2)) SWIG_fail;
33769 }
33770 {
33771 arg3 = wxString_in_helper(obj2);
33772 if (arg3 == NULL) SWIG_fail;
33773 temp3 = true;
33774 }
33775 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33776 if (SWIG_arg_fail(4)) SWIG_fail;
33777 if (obj4) {
33778 {
33779 arg5 = wxString_in_helper(obj4);
33780 if (arg5 == NULL) SWIG_fail;
33781 temp5 = true;
33782 }
33783 }
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33787
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 {
33792 resultobj = wxPyMake_wxObject(result, 0);
33793 }
33794 {
33795 if (temp3)
33796 delete arg3;
33797 }
33798 {
33799 if (temp5)
33800 delete arg5;
33801 }
33802 return resultobj;
33803 fail:
33804 {
33805 if (temp3)
33806 delete arg3;
33807 }
33808 {
33809 if (temp5)
33810 delete arg5;
33811 }
33812 return NULL;
33813 }
33814
33815
33816 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj;
33818 wxMenu *arg1 = (wxMenu *) 0 ;
33819 int arg2 ;
33820 wxMenuItem *result;
33821 PyObject * obj0 = 0 ;
33822 PyObject * obj1 = 0 ;
33823 char *kwnames[] = {
33824 (char *) "self",(char *) "id", NULL
33825 };
33826
33827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33829 if (SWIG_arg_fail(1)) SWIG_fail;
33830 {
33831 arg2 = (int)(SWIG_As_int(obj1));
33832 if (SWIG_arg_fail(2)) SWIG_fail;
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 result = (wxMenuItem *)(arg1)->Remove(arg2);
33837
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 {
33842 resultobj = wxPyMake_wxObject(result, 0);
33843 }
33844 return resultobj;
33845 fail:
33846 return NULL;
33847 }
33848
33849
33850 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33851 PyObject *resultobj;
33852 wxMenu *arg1 = (wxMenu *) 0 ;
33853 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33854 wxMenuItem *result;
33855 PyObject * obj0 = 0 ;
33856 PyObject * obj1 = 0 ;
33857 char *kwnames[] = {
33858 (char *) "self",(char *) "item", NULL
33859 };
33860
33861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33863 if (SWIG_arg_fail(1)) SWIG_fail;
33864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33865 if (SWIG_arg_fail(2)) SWIG_fail;
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 result = (wxMenuItem *)(arg1)->Remove(arg2);
33869
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 {
33874 resultobj = wxPyMake_wxObject(result, 0);
33875 }
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 int arg2 ;
33886 bool result;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char *kwnames[] = {
33890 (char *) "self",(char *) "id", NULL
33891 };
33892
33893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33895 if (SWIG_arg_fail(1)) SWIG_fail;
33896 {
33897 arg2 = (int)(SWIG_As_int(obj1));
33898 if (SWIG_arg_fail(2)) SWIG_fail;
33899 }
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 result = (bool)(arg1)->Delete(arg2);
33903
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 {
33908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj;
33918 wxMenu *arg1 = (wxMenu *) 0 ;
33919 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33920 bool result;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char *kwnames[] = {
33924 (char *) "self",(char *) "item", NULL
33925 };
33926
33927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33929 if (SWIG_arg_fail(1)) SWIG_fail;
33930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(2)) SWIG_fail;
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 result = (bool)(arg1)->Delete(arg2);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 {
33940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33941 }
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj;
33950 wxMenu *arg1 = (wxMenu *) 0 ;
33951 PyObject * obj0 = 0 ;
33952 char *kwnames[] = {
33953 (char *) "self", NULL
33954 };
33955
33956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33958 if (SWIG_arg_fail(1)) SWIG_fail;
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 wxMenu_Destroy(arg1);
33962
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 Py_INCREF(Py_None); resultobj = Py_None;
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj;
33975 wxMenu *arg1 = (wxMenu *) 0 ;
33976 int arg2 ;
33977 bool result;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 char *kwnames[] = {
33981 (char *) "self",(char *) "id", NULL
33982 };
33983
33984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33986 if (SWIG_arg_fail(1)) SWIG_fail;
33987 {
33988 arg2 = (int)(SWIG_As_int(obj1));
33989 if (SWIG_arg_fail(2)) SWIG_fail;
33990 }
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = (bool)(arg1)->Destroy(arg2);
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 {
33999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34000 }
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj;
34009 wxMenu *arg1 = (wxMenu *) 0 ;
34010 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34011 bool result;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 char *kwnames[] = {
34015 (char *) "self",(char *) "item", NULL
34016 };
34017
34018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34020 if (SWIG_arg_fail(1)) SWIG_fail;
34021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34022 if (SWIG_arg_fail(2)) SWIG_fail;
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (bool)(arg1)->Destroy(arg2);
34026
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 {
34031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34032 }
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 size_t result;
34043 PyObject * obj0 = 0 ;
34044 char *kwnames[] = {
34045 (char *) "self", NULL
34046 };
34047
34048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34050 if (SWIG_arg_fail(1)) SWIG_fail;
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34054
34055 wxPyEndAllowThreads(__tstate);
34056 if (PyErr_Occurred()) SWIG_fail;
34057 }
34058 {
34059 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34060 }
34061 return resultobj;
34062 fail:
34063 return NULL;
34064 }
34065
34066
34067 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34068 PyObject *resultobj;
34069 wxMenu *arg1 = (wxMenu *) 0 ;
34070 PyObject *result;
34071 PyObject * obj0 = 0 ;
34072 char *kwnames[] = {
34073 (char *) "self", NULL
34074 };
34075
34076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34078 if (SWIG_arg_fail(1)) SWIG_fail;
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34082
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = result;
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj;
34095 wxMenu *arg1 = (wxMenu *) 0 ;
34096 wxString *arg2 = 0 ;
34097 int result;
34098 bool temp2 = false ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char *kwnames[] = {
34102 (char *) "self",(char *) "item", NULL
34103 };
34104
34105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34107 if (SWIG_arg_fail(1)) SWIG_fail;
34108 {
34109 arg2 = wxString_in_helper(obj1);
34110 if (arg2 == NULL) SWIG_fail;
34111 temp2 = true;
34112 }
34113 {
34114 PyThreadState* __tstate = wxPyBeginAllowThreads();
34115 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34116
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 {
34121 resultobj = SWIG_From_int((int)(result));
34122 }
34123 {
34124 if (temp2)
34125 delete arg2;
34126 }
34127 return resultobj;
34128 fail:
34129 {
34130 if (temp2)
34131 delete arg2;
34132 }
34133 return NULL;
34134 }
34135
34136
34137 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34138 PyObject *resultobj;
34139 wxMenu *arg1 = (wxMenu *) 0 ;
34140 int arg2 ;
34141 wxMenuItem *result;
34142 PyObject * obj0 = 0 ;
34143 PyObject * obj1 = 0 ;
34144 char *kwnames[] = {
34145 (char *) "self",(char *) "id", NULL
34146 };
34147
34148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34150 if (SWIG_arg_fail(1)) SWIG_fail;
34151 {
34152 arg2 = (int)(SWIG_As_int(obj1));
34153 if (SWIG_arg_fail(2)) SWIG_fail;
34154 }
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34158
34159 wxPyEndAllowThreads(__tstate);
34160 if (PyErr_Occurred()) SWIG_fail;
34161 }
34162 {
34163 resultobj = wxPyMake_wxObject(result, 0);
34164 }
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj;
34173 wxMenu *arg1 = (wxMenu *) 0 ;
34174 size_t arg2 ;
34175 wxMenuItem *result;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 char *kwnames[] = {
34179 (char *) "self",(char *) "position", NULL
34180 };
34181
34182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34184 if (SWIG_arg_fail(1)) SWIG_fail;
34185 {
34186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34187 if (SWIG_arg_fail(2)) SWIG_fail;
34188 }
34189 {
34190 PyThreadState* __tstate = wxPyBeginAllowThreads();
34191 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34192
34193 wxPyEndAllowThreads(__tstate);
34194 if (PyErr_Occurred()) SWIG_fail;
34195 }
34196 {
34197 resultobj = wxPyMake_wxObject(result, 0);
34198 }
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj;
34207 wxMenu *arg1 = (wxMenu *) 0 ;
34208 int arg2 ;
34209 bool arg3 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 PyObject * obj2 = 0 ;
34213 char *kwnames[] = {
34214 (char *) "self",(char *) "id",(char *) "enable", NULL
34215 };
34216
34217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34219 if (SWIG_arg_fail(1)) SWIG_fail;
34220 {
34221 arg2 = (int)(SWIG_As_int(obj1));
34222 if (SWIG_arg_fail(2)) SWIG_fail;
34223 }
34224 {
34225 arg3 = (bool)(SWIG_As_bool(obj2));
34226 if (SWIG_arg_fail(3)) SWIG_fail;
34227 }
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->Enable(arg2,arg3);
34231
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 Py_INCREF(Py_None); resultobj = Py_None;
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34243 PyObject *resultobj;
34244 wxMenu *arg1 = (wxMenu *) 0 ;
34245 int arg2 ;
34246 bool result;
34247 PyObject * obj0 = 0 ;
34248 PyObject * obj1 = 0 ;
34249 char *kwnames[] = {
34250 (char *) "self",(char *) "id", NULL
34251 };
34252
34253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34255 if (SWIG_arg_fail(1)) SWIG_fail;
34256 {
34257 arg2 = (int)(SWIG_As_int(obj1));
34258 if (SWIG_arg_fail(2)) SWIG_fail;
34259 }
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34263
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 {
34268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34269 }
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34277 PyObject *resultobj;
34278 wxMenu *arg1 = (wxMenu *) 0 ;
34279 int arg2 ;
34280 bool arg3 ;
34281 PyObject * obj0 = 0 ;
34282 PyObject * obj1 = 0 ;
34283 PyObject * obj2 = 0 ;
34284 char *kwnames[] = {
34285 (char *) "self",(char *) "id",(char *) "check", NULL
34286 };
34287
34288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34290 if (SWIG_arg_fail(1)) SWIG_fail;
34291 {
34292 arg2 = (int)(SWIG_As_int(obj1));
34293 if (SWIG_arg_fail(2)) SWIG_fail;
34294 }
34295 {
34296 arg3 = (bool)(SWIG_As_bool(obj2));
34297 if (SWIG_arg_fail(3)) SWIG_fail;
34298 }
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 (arg1)->Check(arg2,arg3);
34302
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 Py_INCREF(Py_None); resultobj = Py_None;
34307 return resultobj;
34308 fail:
34309 return NULL;
34310 }
34311
34312
34313 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34314 PyObject *resultobj;
34315 wxMenu *arg1 = (wxMenu *) 0 ;
34316 int arg2 ;
34317 bool result;
34318 PyObject * obj0 = 0 ;
34319 PyObject * obj1 = 0 ;
34320 char *kwnames[] = {
34321 (char *) "self",(char *) "id", NULL
34322 };
34323
34324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34326 if (SWIG_arg_fail(1)) SWIG_fail;
34327 {
34328 arg2 = (int)(SWIG_As_int(obj1));
34329 if (SWIG_arg_fail(2)) SWIG_fail;
34330 }
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34334
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 {
34339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34340 }
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj;
34349 wxMenu *arg1 = (wxMenu *) 0 ;
34350 int arg2 ;
34351 wxString *arg3 = 0 ;
34352 bool temp3 = false ;
34353 PyObject * obj0 = 0 ;
34354 PyObject * obj1 = 0 ;
34355 PyObject * obj2 = 0 ;
34356 char *kwnames[] = {
34357 (char *) "self",(char *) "id",(char *) "label", NULL
34358 };
34359
34360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34362 if (SWIG_arg_fail(1)) SWIG_fail;
34363 {
34364 arg2 = (int)(SWIG_As_int(obj1));
34365 if (SWIG_arg_fail(2)) SWIG_fail;
34366 }
34367 {
34368 arg3 = wxString_in_helper(obj2);
34369 if (arg3 == NULL) SWIG_fail;
34370 temp3 = true;
34371 }
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34375
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 Py_INCREF(Py_None); resultobj = Py_None;
34380 {
34381 if (temp3)
34382 delete arg3;
34383 }
34384 return resultobj;
34385 fail:
34386 {
34387 if (temp3)
34388 delete arg3;
34389 }
34390 return NULL;
34391 }
34392
34393
34394 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34395 PyObject *resultobj;
34396 wxMenu *arg1 = (wxMenu *) 0 ;
34397 int arg2 ;
34398 wxString result;
34399 PyObject * obj0 = 0 ;
34400 PyObject * obj1 = 0 ;
34401 char *kwnames[] = {
34402 (char *) "self",(char *) "id", NULL
34403 };
34404
34405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34407 if (SWIG_arg_fail(1)) SWIG_fail;
34408 {
34409 arg2 = (int)(SWIG_As_int(obj1));
34410 if (SWIG_arg_fail(2)) SWIG_fail;
34411 }
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34415
34416 wxPyEndAllowThreads(__tstate);
34417 if (PyErr_Occurred()) SWIG_fail;
34418 }
34419 {
34420 #if wxUSE_UNICODE
34421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34422 #else
34423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34424 #endif
34425 }
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34433 PyObject *resultobj;
34434 wxMenu *arg1 = (wxMenu *) 0 ;
34435 int arg2 ;
34436 wxString *arg3 = 0 ;
34437 bool temp3 = false ;
34438 PyObject * obj0 = 0 ;
34439 PyObject * obj1 = 0 ;
34440 PyObject * obj2 = 0 ;
34441 char *kwnames[] = {
34442 (char *) "self",(char *) "id",(char *) "helpString", NULL
34443 };
34444
34445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34447 if (SWIG_arg_fail(1)) SWIG_fail;
34448 {
34449 arg2 = (int)(SWIG_As_int(obj1));
34450 if (SWIG_arg_fail(2)) SWIG_fail;
34451 }
34452 {
34453 arg3 = wxString_in_helper(obj2);
34454 if (arg3 == NULL) SWIG_fail;
34455 temp3 = true;
34456 }
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34460
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 Py_INCREF(Py_None); resultobj = Py_None;
34465 {
34466 if (temp3)
34467 delete arg3;
34468 }
34469 return resultobj;
34470 fail:
34471 {
34472 if (temp3)
34473 delete arg3;
34474 }
34475 return NULL;
34476 }
34477
34478
34479 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34480 PyObject *resultobj;
34481 wxMenu *arg1 = (wxMenu *) 0 ;
34482 int arg2 ;
34483 wxString result;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 char *kwnames[] = {
34487 (char *) "self",(char *) "id", NULL
34488 };
34489
34490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34492 if (SWIG_arg_fail(1)) SWIG_fail;
34493 {
34494 arg2 = (int)(SWIG_As_int(obj1));
34495 if (SWIG_arg_fail(2)) SWIG_fail;
34496 }
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34500
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 {
34505 #if wxUSE_UNICODE
34506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34507 #else
34508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34509 #endif
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj;
34519 wxMenu *arg1 = (wxMenu *) 0 ;
34520 wxString *arg2 = 0 ;
34521 bool temp2 = false ;
34522 PyObject * obj0 = 0 ;
34523 PyObject * obj1 = 0 ;
34524 char *kwnames[] = {
34525 (char *) "self",(char *) "title", NULL
34526 };
34527
34528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34530 if (SWIG_arg_fail(1)) SWIG_fail;
34531 {
34532 arg2 = wxString_in_helper(obj1);
34533 if (arg2 == NULL) SWIG_fail;
34534 temp2 = true;
34535 }
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 (arg1)->SetTitle((wxString const &)*arg2);
34539
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 Py_INCREF(Py_None); resultobj = Py_None;
34544 {
34545 if (temp2)
34546 delete arg2;
34547 }
34548 return resultobj;
34549 fail:
34550 {
34551 if (temp2)
34552 delete arg2;
34553 }
34554 return NULL;
34555 }
34556
34557
34558 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj;
34560 wxMenu *arg1 = (wxMenu *) 0 ;
34561 wxString result;
34562 PyObject * obj0 = 0 ;
34563 char *kwnames[] = {
34564 (char *) "self", NULL
34565 };
34566
34567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34569 if (SWIG_arg_fail(1)) SWIG_fail;
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 result = ((wxMenu const *)arg1)->GetTitle();
34573
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 {
34578 #if wxUSE_UNICODE
34579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34580 #else
34581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34582 #endif
34583 }
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenu *arg1 = (wxMenu *) 0 ;
34593 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34594 PyObject * obj0 = 0 ;
34595 PyObject * obj1 = 0 ;
34596 char *kwnames[] = {
34597 (char *) "self",(char *) "handler", NULL
34598 };
34599
34600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34602 if (SWIG_arg_fail(1)) SWIG_fail;
34603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34604 if (SWIG_arg_fail(2)) SWIG_fail;
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 (arg1)->SetEventHandler(arg2);
34608
34609 wxPyEndAllowThreads(__tstate);
34610 if (PyErr_Occurred()) SWIG_fail;
34611 }
34612 Py_INCREF(Py_None); resultobj = Py_None;
34613 return resultobj;
34614 fail:
34615 return NULL;
34616 }
34617
34618
34619 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34620 PyObject *resultobj;
34621 wxMenu *arg1 = (wxMenu *) 0 ;
34622 wxEvtHandler *result;
34623 PyObject * obj0 = 0 ;
34624 char *kwnames[] = {
34625 (char *) "self", NULL
34626 };
34627
34628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34630 if (SWIG_arg_fail(1)) SWIG_fail;
34631 {
34632 PyThreadState* __tstate = wxPyBeginAllowThreads();
34633 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34634
34635 wxPyEndAllowThreads(__tstate);
34636 if (PyErr_Occurred()) SWIG_fail;
34637 }
34638 {
34639 resultobj = wxPyMake_wxObject(result, 0);
34640 }
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj;
34649 wxMenu *arg1 = (wxMenu *) 0 ;
34650 wxWindow *arg2 = (wxWindow *) 0 ;
34651 PyObject * obj0 = 0 ;
34652 PyObject * obj1 = 0 ;
34653 char *kwnames[] = {
34654 (char *) "self",(char *) "win", NULL
34655 };
34656
34657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34659 if (SWIG_arg_fail(1)) SWIG_fail;
34660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34661 if (SWIG_arg_fail(2)) SWIG_fail;
34662 {
34663 PyThreadState* __tstate = wxPyBeginAllowThreads();
34664 (arg1)->SetInvokingWindow(arg2);
34665
34666 wxPyEndAllowThreads(__tstate);
34667 if (PyErr_Occurred()) SWIG_fail;
34668 }
34669 Py_INCREF(Py_None); resultobj = Py_None;
34670 return resultobj;
34671 fail:
34672 return NULL;
34673 }
34674
34675
34676 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34677 PyObject *resultobj;
34678 wxMenu *arg1 = (wxMenu *) 0 ;
34679 wxWindow *result;
34680 PyObject * obj0 = 0 ;
34681 char *kwnames[] = {
34682 (char *) "self", NULL
34683 };
34684
34685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34687 if (SWIG_arg_fail(1)) SWIG_fail;
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34691
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 {
34696 resultobj = wxPyMake_wxObject(result, 0);
34697 }
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj;
34706 wxMenu *arg1 = (wxMenu *) 0 ;
34707 long result;
34708 PyObject * obj0 = 0 ;
34709 char *kwnames[] = {
34710 (char *) "self", NULL
34711 };
34712
34713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34715 if (SWIG_arg_fail(1)) SWIG_fail;
34716 {
34717 PyThreadState* __tstate = wxPyBeginAllowThreads();
34718 result = (long)((wxMenu const *)arg1)->GetStyle();
34719
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 {
34724 resultobj = SWIG_From_long((long)(result));
34725 }
34726 return resultobj;
34727 fail:
34728 return NULL;
34729 }
34730
34731
34732 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34733 PyObject *resultobj;
34734 wxMenu *arg1 = (wxMenu *) 0 ;
34735 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 char *kwnames[] = {
34739 (char *) "self",(char *) "source", NULL
34740 };
34741
34742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34744 if (SWIG_arg_fail(1)) SWIG_fail;
34745 if (obj1) {
34746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34747 if (SWIG_arg_fail(2)) SWIG_fail;
34748 }
34749 {
34750 PyThreadState* __tstate = wxPyBeginAllowThreads();
34751 (arg1)->UpdateUI(arg2);
34752
34753 wxPyEndAllowThreads(__tstate);
34754 if (PyErr_Occurred()) SWIG_fail;
34755 }
34756 Py_INCREF(Py_None); resultobj = Py_None;
34757 return resultobj;
34758 fail:
34759 return NULL;
34760 }
34761
34762
34763 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34764 PyObject *resultobj;
34765 wxMenu *arg1 = (wxMenu *) 0 ;
34766 wxMenuBar *result;
34767 PyObject * obj0 = 0 ;
34768 char *kwnames[] = {
34769 (char *) "self", NULL
34770 };
34771
34772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34774 if (SWIG_arg_fail(1)) SWIG_fail;
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34778
34779 wxPyEndAllowThreads(__tstate);
34780 if (PyErr_Occurred()) SWIG_fail;
34781 }
34782 {
34783 resultobj = wxPyMake_wxObject(result, 0);
34784 }
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34792 PyObject *resultobj;
34793 wxMenu *arg1 = (wxMenu *) 0 ;
34794 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34795 PyObject * obj0 = 0 ;
34796 PyObject * obj1 = 0 ;
34797 char *kwnames[] = {
34798 (char *) "self",(char *) "menubar", NULL
34799 };
34800
34801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34803 if (SWIG_arg_fail(1)) SWIG_fail;
34804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34805 if (SWIG_arg_fail(2)) SWIG_fail;
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 (arg1)->Attach(arg2);
34809
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 Py_INCREF(Py_None); resultobj = Py_None;
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34821 PyObject *resultobj;
34822 wxMenu *arg1 = (wxMenu *) 0 ;
34823 PyObject * obj0 = 0 ;
34824 char *kwnames[] = {
34825 (char *) "self", NULL
34826 };
34827
34828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34830 if (SWIG_arg_fail(1)) SWIG_fail;
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 (arg1)->Detach();
34834
34835 wxPyEndAllowThreads(__tstate);
34836 if (PyErr_Occurred()) SWIG_fail;
34837 }
34838 Py_INCREF(Py_None); resultobj = Py_None;
34839 return resultobj;
34840 fail:
34841 return NULL;
34842 }
34843
34844
34845 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34846 PyObject *resultobj;
34847 wxMenu *arg1 = (wxMenu *) 0 ;
34848 bool result;
34849 PyObject * obj0 = 0 ;
34850 char *kwnames[] = {
34851 (char *) "self", NULL
34852 };
34853
34854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34856 if (SWIG_arg_fail(1)) SWIG_fail;
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = (bool)((wxMenu const *)arg1)->IsAttached();
34860
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 {
34865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34866 }
34867 return resultobj;
34868 fail:
34869 return NULL;
34870 }
34871
34872
34873 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj;
34875 wxMenu *arg1 = (wxMenu *) 0 ;
34876 wxMenu *arg2 = (wxMenu *) 0 ;
34877 PyObject * obj0 = 0 ;
34878 PyObject * obj1 = 0 ;
34879 char *kwnames[] = {
34880 (char *) "self",(char *) "parent", NULL
34881 };
34882
34883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34885 if (SWIG_arg_fail(1)) SWIG_fail;
34886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34887 if (SWIG_arg_fail(2)) SWIG_fail;
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 (arg1)->SetParent(arg2);
34891
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 Py_INCREF(Py_None); resultobj = Py_None;
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj;
34904 wxMenu *arg1 = (wxMenu *) 0 ;
34905 wxMenu *result;
34906 PyObject * obj0 = 0 ;
34907 char *kwnames[] = {
34908 (char *) "self", NULL
34909 };
34910
34911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34913 if (SWIG_arg_fail(1)) SWIG_fail;
34914 {
34915 PyThreadState* __tstate = wxPyBeginAllowThreads();
34916 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34917
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 {
34922 resultobj = wxPyMake_wxObject(result, 0);
34923 }
34924 return resultobj;
34925 fail:
34926 return NULL;
34927 }
34928
34929
34930 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34931 PyObject *obj;
34932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34933 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34934 Py_INCREF(obj);
34935 return Py_BuildValue((char *)"");
34936 }
34937 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34938 PyObject *resultobj;
34939 long arg1 = (long) 0 ;
34940 wxMenuBar *result;
34941 PyObject * obj0 = 0 ;
34942 char *kwnames[] = {
34943 (char *) "style", NULL
34944 };
34945
34946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34947 if (obj0) {
34948 {
34949 arg1 = (long)(SWIG_As_long(obj0));
34950 if (SWIG_arg_fail(1)) SWIG_fail;
34951 }
34952 }
34953 {
34954 if (!wxPyCheckForApp()) SWIG_fail;
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (wxMenuBar *)new wxMenuBar(arg1);
34957
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34969 PyObject *resultobj;
34970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34971 wxMenu *arg2 = (wxMenu *) 0 ;
34972 wxString *arg3 = 0 ;
34973 bool result;
34974 bool temp3 = false ;
34975 PyObject * obj0 = 0 ;
34976 PyObject * obj1 = 0 ;
34977 PyObject * obj2 = 0 ;
34978 char *kwnames[] = {
34979 (char *) "self",(char *) "menu",(char *) "title", NULL
34980 };
34981
34982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34984 if (SWIG_arg_fail(1)) SWIG_fail;
34985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34986 if (SWIG_arg_fail(2)) SWIG_fail;
34987 {
34988 arg3 = wxString_in_helper(obj2);
34989 if (arg3 == NULL) SWIG_fail;
34990 temp3 = true;
34991 }
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34995
34996 wxPyEndAllowThreads(__tstate);
34997 if (PyErr_Occurred()) SWIG_fail;
34998 }
34999 {
35000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35001 }
35002 {
35003 if (temp3)
35004 delete arg3;
35005 }
35006 return resultobj;
35007 fail:
35008 {
35009 if (temp3)
35010 delete arg3;
35011 }
35012 return NULL;
35013 }
35014
35015
35016 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35017 PyObject *resultobj;
35018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35019 size_t arg2 ;
35020 wxMenu *arg3 = (wxMenu *) 0 ;
35021 wxString *arg4 = 0 ;
35022 bool result;
35023 bool temp4 = false ;
35024 PyObject * obj0 = 0 ;
35025 PyObject * obj1 = 0 ;
35026 PyObject * obj2 = 0 ;
35027 PyObject * obj3 = 0 ;
35028 char *kwnames[] = {
35029 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35030 };
35031
35032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35034 if (SWIG_arg_fail(1)) SWIG_fail;
35035 {
35036 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35037 if (SWIG_arg_fail(2)) SWIG_fail;
35038 }
35039 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35040 if (SWIG_arg_fail(3)) SWIG_fail;
35041 {
35042 arg4 = wxString_in_helper(obj3);
35043 if (arg4 == NULL) SWIG_fail;
35044 temp4 = true;
35045 }
35046 {
35047 PyThreadState* __tstate = wxPyBeginAllowThreads();
35048 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35049
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 {
35054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35055 }
35056 {
35057 if (temp4)
35058 delete arg4;
35059 }
35060 return resultobj;
35061 fail:
35062 {
35063 if (temp4)
35064 delete arg4;
35065 }
35066 return NULL;
35067 }
35068
35069
35070 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35071 PyObject *resultobj;
35072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35073 size_t result;
35074 PyObject * obj0 = 0 ;
35075 char *kwnames[] = {
35076 (char *) "self", NULL
35077 };
35078
35079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35081 if (SWIG_arg_fail(1)) SWIG_fail;
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35085
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 {
35090 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35091 }
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj;
35100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35101 size_t arg2 ;
35102 wxMenu *result;
35103 PyObject * obj0 = 0 ;
35104 PyObject * obj1 = 0 ;
35105 char *kwnames[] = {
35106 (char *) "self",(char *) "pos", NULL
35107 };
35108
35109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35111 if (SWIG_arg_fail(1)) SWIG_fail;
35112 {
35113 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35114 if (SWIG_arg_fail(2)) SWIG_fail;
35115 }
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35119
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 {
35124 resultobj = wxPyMake_wxObject(result, 0);
35125 }
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj;
35134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35135 size_t arg2 ;
35136 wxMenu *arg3 = (wxMenu *) 0 ;
35137 wxString *arg4 = 0 ;
35138 wxMenu *result;
35139 bool temp4 = false ;
35140 PyObject * obj0 = 0 ;
35141 PyObject * obj1 = 0 ;
35142 PyObject * obj2 = 0 ;
35143 PyObject * obj3 = 0 ;
35144 char *kwnames[] = {
35145 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35146 };
35147
35148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35150 if (SWIG_arg_fail(1)) SWIG_fail;
35151 {
35152 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35153 if (SWIG_arg_fail(2)) SWIG_fail;
35154 }
35155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35156 if (SWIG_arg_fail(3)) SWIG_fail;
35157 {
35158 arg4 = wxString_in_helper(obj3);
35159 if (arg4 == NULL) SWIG_fail;
35160 temp4 = true;
35161 }
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35165
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 {
35170 resultobj = wxPyMake_wxObject(result, 0);
35171 }
35172 {
35173 if (temp4)
35174 delete arg4;
35175 }
35176 return resultobj;
35177 fail:
35178 {
35179 if (temp4)
35180 delete arg4;
35181 }
35182 return NULL;
35183 }
35184
35185
35186 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35187 PyObject *resultobj;
35188 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35189 size_t arg2 ;
35190 wxMenu *result;
35191 PyObject * obj0 = 0 ;
35192 PyObject * obj1 = 0 ;
35193 char *kwnames[] = {
35194 (char *) "self",(char *) "pos", NULL
35195 };
35196
35197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35199 if (SWIG_arg_fail(1)) SWIG_fail;
35200 {
35201 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35202 if (SWIG_arg_fail(2)) SWIG_fail;
35203 }
35204 {
35205 PyThreadState* __tstate = wxPyBeginAllowThreads();
35206 result = (wxMenu *)(arg1)->Remove(arg2);
35207
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 {
35212 resultobj = wxPyMake_wxObject(result, 0);
35213 }
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj;
35222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35223 size_t arg2 ;
35224 bool arg3 ;
35225 PyObject * obj0 = 0 ;
35226 PyObject * obj1 = 0 ;
35227 PyObject * obj2 = 0 ;
35228 char *kwnames[] = {
35229 (char *) "self",(char *) "pos",(char *) "enable", NULL
35230 };
35231
35232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35234 if (SWIG_arg_fail(1)) SWIG_fail;
35235 {
35236 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35237 if (SWIG_arg_fail(2)) SWIG_fail;
35238 }
35239 {
35240 arg3 = (bool)(SWIG_As_bool(obj2));
35241 if (SWIG_arg_fail(3)) SWIG_fail;
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->EnableTop(arg2,arg3);
35246
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 Py_INCREF(Py_None); resultobj = Py_None;
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj;
35259 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35260 size_t arg2 ;
35261 bool result;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 char *kwnames[] = {
35265 (char *) "self",(char *) "pos", NULL
35266 };
35267
35268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35270 if (SWIG_arg_fail(1)) SWIG_fail;
35271 {
35272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35273 if (SWIG_arg_fail(2)) SWIG_fail;
35274 }
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35278
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 {
35283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35284 }
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj;
35293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35294 size_t arg2 ;
35295 wxString *arg3 = 0 ;
35296 bool temp3 = false ;
35297 PyObject * obj0 = 0 ;
35298 PyObject * obj1 = 0 ;
35299 PyObject * obj2 = 0 ;
35300 char *kwnames[] = {
35301 (char *) "self",(char *) "pos",(char *) "label", NULL
35302 };
35303
35304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35306 if (SWIG_arg_fail(1)) SWIG_fail;
35307 {
35308 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35309 if (SWIG_arg_fail(2)) SWIG_fail;
35310 }
35311 {
35312 arg3 = wxString_in_helper(obj2);
35313 if (arg3 == NULL) SWIG_fail;
35314 temp3 = true;
35315 }
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35319
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 Py_INCREF(Py_None); resultobj = Py_None;
35324 {
35325 if (temp3)
35326 delete arg3;
35327 }
35328 return resultobj;
35329 fail:
35330 {
35331 if (temp3)
35332 delete arg3;
35333 }
35334 return NULL;
35335 }
35336
35337
35338 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35339 PyObject *resultobj;
35340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35341 size_t arg2 ;
35342 wxString result;
35343 PyObject * obj0 = 0 ;
35344 PyObject * obj1 = 0 ;
35345 char *kwnames[] = {
35346 (char *) "self",(char *) "pos", NULL
35347 };
35348
35349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35351 if (SWIG_arg_fail(1)) SWIG_fail;
35352 {
35353 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35354 if (SWIG_arg_fail(2)) SWIG_fail;
35355 }
35356 {
35357 PyThreadState* __tstate = wxPyBeginAllowThreads();
35358 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35359
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 {
35364 #if wxUSE_UNICODE
35365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35366 #else
35367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35368 #endif
35369 }
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35377 PyObject *resultobj;
35378 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35379 wxString *arg2 = 0 ;
35380 wxString *arg3 = 0 ;
35381 int result;
35382 bool temp2 = false ;
35383 bool temp3 = false ;
35384 PyObject * obj0 = 0 ;
35385 PyObject * obj1 = 0 ;
35386 PyObject * obj2 = 0 ;
35387 char *kwnames[] = {
35388 (char *) "self",(char *) "menu",(char *) "item", NULL
35389 };
35390
35391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35393 if (SWIG_arg_fail(1)) SWIG_fail;
35394 {
35395 arg2 = wxString_in_helper(obj1);
35396 if (arg2 == NULL) SWIG_fail;
35397 temp2 = true;
35398 }
35399 {
35400 arg3 = wxString_in_helper(obj2);
35401 if (arg3 == NULL) SWIG_fail;
35402 temp3 = true;
35403 }
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35407
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 {
35412 resultobj = SWIG_From_int((int)(result));
35413 }
35414 {
35415 if (temp2)
35416 delete arg2;
35417 }
35418 {
35419 if (temp3)
35420 delete arg3;
35421 }
35422 return resultobj;
35423 fail:
35424 {
35425 if (temp2)
35426 delete arg2;
35427 }
35428 {
35429 if (temp3)
35430 delete arg3;
35431 }
35432 return NULL;
35433 }
35434
35435
35436 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35437 PyObject *resultobj;
35438 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35439 int arg2 ;
35440 wxMenuItem *result;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char *kwnames[] = {
35444 (char *) "self",(char *) "id", NULL
35445 };
35446
35447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35449 if (SWIG_arg_fail(1)) SWIG_fail;
35450 {
35451 arg2 = (int)(SWIG_As_int(obj1));
35452 if (SWIG_arg_fail(2)) SWIG_fail;
35453 }
35454 {
35455 PyThreadState* __tstate = wxPyBeginAllowThreads();
35456 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35457
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 {
35462 resultobj = wxPyMake_wxObject(result, 0);
35463 }
35464 return resultobj;
35465 fail:
35466 return NULL;
35467 }
35468
35469
35470 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35471 PyObject *resultobj;
35472 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35473 wxString *arg2 = 0 ;
35474 int result;
35475 bool temp2 = false ;
35476 PyObject * obj0 = 0 ;
35477 PyObject * obj1 = 0 ;
35478 char *kwnames[] = {
35479 (char *) "self",(char *) "title", NULL
35480 };
35481
35482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35484 if (SWIG_arg_fail(1)) SWIG_fail;
35485 {
35486 arg2 = wxString_in_helper(obj1);
35487 if (arg2 == NULL) SWIG_fail;
35488 temp2 = true;
35489 }
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35493
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 {
35498 resultobj = SWIG_From_int((int)(result));
35499 }
35500 {
35501 if (temp2)
35502 delete arg2;
35503 }
35504 return resultobj;
35505 fail:
35506 {
35507 if (temp2)
35508 delete arg2;
35509 }
35510 return NULL;
35511 }
35512
35513
35514 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35515 PyObject *resultobj;
35516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35517 int arg2 ;
35518 bool arg3 ;
35519 PyObject * obj0 = 0 ;
35520 PyObject * obj1 = 0 ;
35521 PyObject * obj2 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self",(char *) "id",(char *) "enable", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 arg2 = (int)(SWIG_As_int(obj1));
35531 if (SWIG_arg_fail(2)) SWIG_fail;
35532 }
35533 {
35534 arg3 = (bool)(SWIG_As_bool(obj2));
35535 if (SWIG_arg_fail(3)) SWIG_fail;
35536 }
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 (arg1)->Enable(arg2,arg3);
35540
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 Py_INCREF(Py_None); resultobj = Py_None;
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj;
35553 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35554 int arg2 ;
35555 bool arg3 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 PyObject * obj2 = 0 ;
35559 char *kwnames[] = {
35560 (char *) "self",(char *) "id",(char *) "check", NULL
35561 };
35562
35563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35565 if (SWIG_arg_fail(1)) SWIG_fail;
35566 {
35567 arg2 = (int)(SWIG_As_int(obj1));
35568 if (SWIG_arg_fail(2)) SWIG_fail;
35569 }
35570 {
35571 arg3 = (bool)(SWIG_As_bool(obj2));
35572 if (SWIG_arg_fail(3)) SWIG_fail;
35573 }
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->Check(arg2,arg3);
35577
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 Py_INCREF(Py_None); resultobj = Py_None;
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35589 PyObject *resultobj;
35590 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35591 int arg2 ;
35592 bool result;
35593 PyObject * obj0 = 0 ;
35594 PyObject * obj1 = 0 ;
35595 char *kwnames[] = {
35596 (char *) "self",(char *) "id", NULL
35597 };
35598
35599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35601 if (SWIG_arg_fail(1)) SWIG_fail;
35602 {
35603 arg2 = (int)(SWIG_As_int(obj1));
35604 if (SWIG_arg_fail(2)) SWIG_fail;
35605 }
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35609
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 {
35614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35615 }
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35623 PyObject *resultobj;
35624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35625 int arg2 ;
35626 bool result;
35627 PyObject * obj0 = 0 ;
35628 PyObject * obj1 = 0 ;
35629 char *kwnames[] = {
35630 (char *) "self",(char *) "id", NULL
35631 };
35632
35633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35635 if (SWIG_arg_fail(1)) SWIG_fail;
35636 {
35637 arg2 = (int)(SWIG_As_int(obj1));
35638 if (SWIG_arg_fail(2)) SWIG_fail;
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35643
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35659 int arg2 ;
35660 wxString *arg3 = 0 ;
35661 bool temp3 = false ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 PyObject * obj2 = 0 ;
35665 char *kwnames[] = {
35666 (char *) "self",(char *) "id",(char *) "label", NULL
35667 };
35668
35669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35671 if (SWIG_arg_fail(1)) SWIG_fail;
35672 {
35673 arg2 = (int)(SWIG_As_int(obj1));
35674 if (SWIG_arg_fail(2)) SWIG_fail;
35675 }
35676 {
35677 arg3 = wxString_in_helper(obj2);
35678 if (arg3 == NULL) SWIG_fail;
35679 temp3 = true;
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35684
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 Py_INCREF(Py_None); resultobj = Py_None;
35689 {
35690 if (temp3)
35691 delete arg3;
35692 }
35693 return resultobj;
35694 fail:
35695 {
35696 if (temp3)
35697 delete arg3;
35698 }
35699 return NULL;
35700 }
35701
35702
35703 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35704 PyObject *resultobj;
35705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35706 int arg2 ;
35707 wxString result;
35708 PyObject * obj0 = 0 ;
35709 PyObject * obj1 = 0 ;
35710 char *kwnames[] = {
35711 (char *) "self",(char *) "id", NULL
35712 };
35713
35714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35716 if (SWIG_arg_fail(1)) SWIG_fail;
35717 {
35718 arg2 = (int)(SWIG_As_int(obj1));
35719 if (SWIG_arg_fail(2)) SWIG_fail;
35720 }
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35724
35725 wxPyEndAllowThreads(__tstate);
35726 if (PyErr_Occurred()) SWIG_fail;
35727 }
35728 {
35729 #if wxUSE_UNICODE
35730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35731 #else
35732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35733 #endif
35734 }
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35742 PyObject *resultobj;
35743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35744 int arg2 ;
35745 wxString *arg3 = 0 ;
35746 bool temp3 = false ;
35747 PyObject * obj0 = 0 ;
35748 PyObject * obj1 = 0 ;
35749 PyObject * obj2 = 0 ;
35750 char *kwnames[] = {
35751 (char *) "self",(char *) "id",(char *) "helpString", NULL
35752 };
35753
35754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35756 if (SWIG_arg_fail(1)) SWIG_fail;
35757 {
35758 arg2 = (int)(SWIG_As_int(obj1));
35759 if (SWIG_arg_fail(2)) SWIG_fail;
35760 }
35761 {
35762 arg3 = wxString_in_helper(obj2);
35763 if (arg3 == NULL) SWIG_fail;
35764 temp3 = true;
35765 }
35766 {
35767 PyThreadState* __tstate = wxPyBeginAllowThreads();
35768 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35769
35770 wxPyEndAllowThreads(__tstate);
35771 if (PyErr_Occurred()) SWIG_fail;
35772 }
35773 Py_INCREF(Py_None); resultobj = Py_None;
35774 {
35775 if (temp3)
35776 delete arg3;
35777 }
35778 return resultobj;
35779 fail:
35780 {
35781 if (temp3)
35782 delete arg3;
35783 }
35784 return NULL;
35785 }
35786
35787
35788 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35789 PyObject *resultobj;
35790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35791 int arg2 ;
35792 wxString result;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self",(char *) "id", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 arg2 = (int)(SWIG_As_int(obj1));
35804 if (SWIG_arg_fail(2)) SWIG_fail;
35805 }
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35809
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 {
35814 #if wxUSE_UNICODE
35815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35816 #else
35817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35818 #endif
35819 }
35820 return resultobj;
35821 fail:
35822 return NULL;
35823 }
35824
35825
35826 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35827 PyObject *resultobj;
35828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35829 wxFrame *result;
35830 PyObject * obj0 = 0 ;
35831 char *kwnames[] = {
35832 (char *) "self", NULL
35833 };
35834
35835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35837 if (SWIG_arg_fail(1)) SWIG_fail;
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35841
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 {
35846 resultobj = wxPyMake_wxObject(result, 0);
35847 }
35848 return resultobj;
35849 fail:
35850 return NULL;
35851 }
35852
35853
35854 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj;
35856 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35857 bool result;
35858 PyObject * obj0 = 0 ;
35859 char *kwnames[] = {
35860 (char *) "self", NULL
35861 };
35862
35863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35865 if (SWIG_arg_fail(1)) SWIG_fail;
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35869
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 {
35874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35875 }
35876 return resultobj;
35877 fail:
35878 return NULL;
35879 }
35880
35881
35882 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35883 PyObject *resultobj;
35884 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35885 wxFrame *arg2 = (wxFrame *) 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 char *kwnames[] = {
35889 (char *) "self",(char *) "frame", NULL
35890 };
35891
35892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35894 if (SWIG_arg_fail(1)) SWIG_fail;
35895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35896 if (SWIG_arg_fail(2)) SWIG_fail;
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->Attach(arg2);
35900
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 Py_INCREF(Py_None); resultobj = Py_None;
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj;
35913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35914 PyObject * obj0 = 0 ;
35915 char *kwnames[] = {
35916 (char *) "self", NULL
35917 };
35918
35919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35921 if (SWIG_arg_fail(1)) SWIG_fail;
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 (arg1)->Detach();
35925
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 Py_INCREF(Py_None); resultobj = Py_None;
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35937 PyObject *obj;
35938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35939 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35940 Py_INCREF(obj);
35941 return Py_BuildValue((char *)"");
35942 }
35943 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj;
35945 wxMenu *arg1 = (wxMenu *) NULL ;
35946 int arg2 = (int) wxID_ANY ;
35947 wxString const &arg3_defvalue = wxPyEmptyString ;
35948 wxString *arg3 = (wxString *) &arg3_defvalue ;
35949 wxString const &arg4_defvalue = wxPyEmptyString ;
35950 wxString *arg4 = (wxString *) &arg4_defvalue ;
35951 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35952 wxMenu *arg6 = (wxMenu *) NULL ;
35953 wxMenuItem *result;
35954 bool temp3 = false ;
35955 bool temp4 = false ;
35956 PyObject * obj0 = 0 ;
35957 PyObject * obj1 = 0 ;
35958 PyObject * obj2 = 0 ;
35959 PyObject * obj3 = 0 ;
35960 PyObject * obj4 = 0 ;
35961 PyObject * obj5 = 0 ;
35962 char *kwnames[] = {
35963 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35964 };
35965
35966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35967 if (obj0) {
35968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35969 if (SWIG_arg_fail(1)) SWIG_fail;
35970 }
35971 if (obj1) {
35972 {
35973 arg2 = (int)(SWIG_As_int(obj1));
35974 if (SWIG_arg_fail(2)) SWIG_fail;
35975 }
35976 }
35977 if (obj2) {
35978 {
35979 arg3 = wxString_in_helper(obj2);
35980 if (arg3 == NULL) SWIG_fail;
35981 temp3 = true;
35982 }
35983 }
35984 if (obj3) {
35985 {
35986 arg4 = wxString_in_helper(obj3);
35987 if (arg4 == NULL) SWIG_fail;
35988 temp4 = true;
35989 }
35990 }
35991 if (obj4) {
35992 {
35993 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35994 if (SWIG_arg_fail(5)) SWIG_fail;
35995 }
35996 }
35997 if (obj5) {
35998 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35999 if (SWIG_arg_fail(6)) SWIG_fail;
36000 }
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36004
36005 wxPyEndAllowThreads(__tstate);
36006 if (PyErr_Occurred()) SWIG_fail;
36007 }
36008 {
36009 resultobj = wxPyMake_wxObject(result, 1);
36010 }
36011 {
36012 if (temp3)
36013 delete arg3;
36014 }
36015 {
36016 if (temp4)
36017 delete arg4;
36018 }
36019 return resultobj;
36020 fail:
36021 {
36022 if (temp3)
36023 delete arg3;
36024 }
36025 {
36026 if (temp4)
36027 delete arg4;
36028 }
36029 return NULL;
36030 }
36031
36032
36033 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj;
36035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36036 wxMenu *result;
36037 PyObject * obj0 = 0 ;
36038 char *kwnames[] = {
36039 (char *) "self", NULL
36040 };
36041
36042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36044 if (SWIG_arg_fail(1)) SWIG_fail;
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36048
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = wxPyMake_wxObject(result, 0);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj;
36063 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36064 wxMenu *arg2 = (wxMenu *) 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char *kwnames[] = {
36068 (char *) "self",(char *) "menu", NULL
36069 };
36070
36071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36073 if (SWIG_arg_fail(1)) SWIG_fail;
36074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36075 if (SWIG_arg_fail(2)) SWIG_fail;
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 (arg1)->SetMenu(arg2);
36079
36080 wxPyEndAllowThreads(__tstate);
36081 if (PyErr_Occurred()) SWIG_fail;
36082 }
36083 Py_INCREF(Py_None); resultobj = Py_None;
36084 return resultobj;
36085 fail:
36086 return NULL;
36087 }
36088
36089
36090 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36091 PyObject *resultobj;
36092 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36093 int arg2 ;
36094 PyObject * obj0 = 0 ;
36095 PyObject * obj1 = 0 ;
36096 char *kwnames[] = {
36097 (char *) "self",(char *) "id", NULL
36098 };
36099
36100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36102 if (SWIG_arg_fail(1)) SWIG_fail;
36103 {
36104 arg2 = (int)(SWIG_As_int(obj1));
36105 if (SWIG_arg_fail(2)) SWIG_fail;
36106 }
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 (arg1)->SetId(arg2);
36110
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 Py_INCREF(Py_None); resultobj = Py_None;
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36122 PyObject *resultobj;
36123 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36124 int result;
36125 PyObject * obj0 = 0 ;
36126 char *kwnames[] = {
36127 (char *) "self", NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36132 if (SWIG_arg_fail(1)) SWIG_fail;
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 result = (int)((wxMenuItem const *)arg1)->GetId();
36136
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 {
36141 resultobj = SWIG_From_int((int)(result));
36142 }
36143 return resultobj;
36144 fail:
36145 return NULL;
36146 }
36147
36148
36149 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36150 PyObject *resultobj;
36151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36152 bool result;
36153 PyObject * obj0 = 0 ;
36154 char *kwnames[] = {
36155 (char *) "self", NULL
36156 };
36157
36158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(1)) SWIG_fail;
36161 {
36162 PyThreadState* __tstate = wxPyBeginAllowThreads();
36163 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36164
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 {
36169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36170 }
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36178 PyObject *resultobj;
36179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36180 wxString *arg2 = 0 ;
36181 bool temp2 = false ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 char *kwnames[] = {
36185 (char *) "self",(char *) "str", NULL
36186 };
36187
36188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36190 if (SWIG_arg_fail(1)) SWIG_fail;
36191 {
36192 arg2 = wxString_in_helper(obj1);
36193 if (arg2 == NULL) SWIG_fail;
36194 temp2 = true;
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 (arg1)->SetText((wxString const &)*arg2);
36199
36200 wxPyEndAllowThreads(__tstate);
36201 if (PyErr_Occurred()) SWIG_fail;
36202 }
36203 Py_INCREF(Py_None); resultobj = Py_None;
36204 {
36205 if (temp2)
36206 delete arg2;
36207 }
36208 return resultobj;
36209 fail:
36210 {
36211 if (temp2)
36212 delete arg2;
36213 }
36214 return NULL;
36215 }
36216
36217
36218 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36219 PyObject *resultobj;
36220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36221 wxString result;
36222 PyObject * obj0 = 0 ;
36223 char *kwnames[] = {
36224 (char *) "self", NULL
36225 };
36226
36227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36229 if (SWIG_arg_fail(1)) SWIG_fail;
36230 {
36231 PyThreadState* __tstate = wxPyBeginAllowThreads();
36232 result = ((wxMenuItem const *)arg1)->GetLabel();
36233
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 {
36238 #if wxUSE_UNICODE
36239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36240 #else
36241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36242 #endif
36243 }
36244 return resultobj;
36245 fail:
36246 return NULL;
36247 }
36248
36249
36250 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj;
36252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36253 wxString *result;
36254 PyObject * obj0 = 0 ;
36255 char *kwnames[] = {
36256 (char *) "self", NULL
36257 };
36258
36259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(1)) SWIG_fail;
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 {
36265 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36266 result = (wxString *) &_result_ref;
36267 }
36268
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 {
36273 #if wxUSE_UNICODE
36274 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36275 #else
36276 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36277 #endif
36278 }
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj;
36287 wxString *arg1 = 0 ;
36288 wxString result;
36289 bool temp1 = false ;
36290 PyObject * obj0 = 0 ;
36291 char *kwnames[] = {
36292 (char *) "text", NULL
36293 };
36294
36295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36296 {
36297 arg1 = wxString_in_helper(obj0);
36298 if (arg1 == NULL) SWIG_fail;
36299 temp1 = true;
36300 }
36301 {
36302 PyThreadState* __tstate = wxPyBeginAllowThreads();
36303 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36304
36305 wxPyEndAllowThreads(__tstate);
36306 if (PyErr_Occurred()) SWIG_fail;
36307 }
36308 {
36309 #if wxUSE_UNICODE
36310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36311 #else
36312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36313 #endif
36314 }
36315 {
36316 if (temp1)
36317 delete arg1;
36318 }
36319 return resultobj;
36320 fail:
36321 {
36322 if (temp1)
36323 delete arg1;
36324 }
36325 return NULL;
36326 }
36327
36328
36329 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36330 PyObject *resultobj;
36331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36332 wxItemKind result;
36333 PyObject * obj0 = 0 ;
36334 char *kwnames[] = {
36335 (char *) "self", NULL
36336 };
36337
36338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36340 if (SWIG_arg_fail(1)) SWIG_fail;
36341 {
36342 PyThreadState* __tstate = wxPyBeginAllowThreads();
36343 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36344
36345 wxPyEndAllowThreads(__tstate);
36346 if (PyErr_Occurred()) SWIG_fail;
36347 }
36348 resultobj = SWIG_From_int((result));
36349 return resultobj;
36350 fail:
36351 return NULL;
36352 }
36353
36354
36355 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36356 PyObject *resultobj;
36357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36358 wxItemKind arg2 ;
36359 PyObject * obj0 = 0 ;
36360 PyObject * obj1 = 0 ;
36361 char *kwnames[] = {
36362 (char *) "self",(char *) "kind", NULL
36363 };
36364
36365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36367 if (SWIG_arg_fail(1)) SWIG_fail;
36368 {
36369 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36370 if (SWIG_arg_fail(2)) SWIG_fail;
36371 }
36372 {
36373 PyThreadState* __tstate = wxPyBeginAllowThreads();
36374 (arg1)->SetKind((wxItemKind )arg2);
36375
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 Py_INCREF(Py_None); resultobj = Py_None;
36380 return resultobj;
36381 fail:
36382 return NULL;
36383 }
36384
36385
36386 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36387 PyObject *resultobj;
36388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36389 bool arg2 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 char *kwnames[] = {
36393 (char *) "self",(char *) "checkable", NULL
36394 };
36395
36396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36398 if (SWIG_arg_fail(1)) SWIG_fail;
36399 {
36400 arg2 = (bool)(SWIG_As_bool(obj1));
36401 if (SWIG_arg_fail(2)) SWIG_fail;
36402 }
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 (arg1)->SetCheckable(arg2);
36406
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 Py_INCREF(Py_None); resultobj = Py_None;
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj;
36419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36420 bool result;
36421 PyObject * obj0 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36432
36433 wxPyEndAllowThreads(__tstate);
36434 if (PyErr_Occurred()) SWIG_fail;
36435 }
36436 {
36437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36438 }
36439 return resultobj;
36440 fail:
36441 return NULL;
36442 }
36443
36444
36445 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36446 PyObject *resultobj;
36447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36448 bool result;
36449 PyObject * obj0 = 0 ;
36450 char *kwnames[] = {
36451 (char *) "self", NULL
36452 };
36453
36454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36456 if (SWIG_arg_fail(1)) SWIG_fail;
36457 {
36458 PyThreadState* __tstate = wxPyBeginAllowThreads();
36459 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36460
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 {
36465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36466 }
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36474 PyObject *resultobj;
36475 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36476 wxMenu *arg2 = (wxMenu *) 0 ;
36477 PyObject * obj0 = 0 ;
36478 PyObject * obj1 = 0 ;
36479 char *kwnames[] = {
36480 (char *) "self",(char *) "menu", NULL
36481 };
36482
36483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36485 if (SWIG_arg_fail(1)) SWIG_fail;
36486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36487 if (SWIG_arg_fail(2)) SWIG_fail;
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 (arg1)->SetSubMenu(arg2);
36491
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 Py_INCREF(Py_None); resultobj = Py_None;
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj;
36504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36505 wxMenu *result;
36506 PyObject * obj0 = 0 ;
36507 char *kwnames[] = {
36508 (char *) "self", NULL
36509 };
36510
36511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36513 if (SWIG_arg_fail(1)) SWIG_fail;
36514 {
36515 PyThreadState* __tstate = wxPyBeginAllowThreads();
36516 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36517
36518 wxPyEndAllowThreads(__tstate);
36519 if (PyErr_Occurred()) SWIG_fail;
36520 }
36521 {
36522 resultobj = wxPyMake_wxObject(result, 0);
36523 }
36524 return resultobj;
36525 fail:
36526 return NULL;
36527 }
36528
36529
36530 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36531 PyObject *resultobj;
36532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36533 bool arg2 = (bool) true ;
36534 PyObject * obj0 = 0 ;
36535 PyObject * obj1 = 0 ;
36536 char *kwnames[] = {
36537 (char *) "self",(char *) "enable", NULL
36538 };
36539
36540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36542 if (SWIG_arg_fail(1)) SWIG_fail;
36543 if (obj1) {
36544 {
36545 arg2 = (bool)(SWIG_As_bool(obj1));
36546 if (SWIG_arg_fail(2)) SWIG_fail;
36547 }
36548 }
36549 {
36550 PyThreadState* __tstate = wxPyBeginAllowThreads();
36551 (arg1)->Enable(arg2);
36552
36553 wxPyEndAllowThreads(__tstate);
36554 if (PyErr_Occurred()) SWIG_fail;
36555 }
36556 Py_INCREF(Py_None); resultobj = Py_None;
36557 return resultobj;
36558 fail:
36559 return NULL;
36560 }
36561
36562
36563 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36564 PyObject *resultobj;
36565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36566 bool result;
36567 PyObject * obj0 = 0 ;
36568 char *kwnames[] = {
36569 (char *) "self", NULL
36570 };
36571
36572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36574 if (SWIG_arg_fail(1)) SWIG_fail;
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36578
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 {
36583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36584 }
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj;
36593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36594 bool arg2 = (bool) true ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 char *kwnames[] = {
36598 (char *) "self",(char *) "check", NULL
36599 };
36600
36601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36603 if (SWIG_arg_fail(1)) SWIG_fail;
36604 if (obj1) {
36605 {
36606 arg2 = (bool)(SWIG_As_bool(obj1));
36607 if (SWIG_arg_fail(2)) SWIG_fail;
36608 }
36609 }
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 (arg1)->Check(arg2);
36613
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 Py_INCREF(Py_None); resultobj = Py_None;
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36625 PyObject *resultobj;
36626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36627 bool result;
36628 PyObject * obj0 = 0 ;
36629 char *kwnames[] = {
36630 (char *) "self", NULL
36631 };
36632
36633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36635 if (SWIG_arg_fail(1)) SWIG_fail;
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36639
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 {
36644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj;
36654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36655 PyObject * obj0 = 0 ;
36656 char *kwnames[] = {
36657 (char *) "self", NULL
36658 };
36659
36660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36662 if (SWIG_arg_fail(1)) SWIG_fail;
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 (arg1)->Toggle();
36666
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 Py_INCREF(Py_None); resultobj = Py_None;
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj;
36679 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36680 wxString *arg2 = 0 ;
36681 bool temp2 = false ;
36682 PyObject * obj0 = 0 ;
36683 PyObject * obj1 = 0 ;
36684 char *kwnames[] = {
36685 (char *) "self",(char *) "str", NULL
36686 };
36687
36688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36690 if (SWIG_arg_fail(1)) SWIG_fail;
36691 {
36692 arg2 = wxString_in_helper(obj1);
36693 if (arg2 == NULL) SWIG_fail;
36694 temp2 = true;
36695 }
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 (arg1)->SetHelp((wxString const &)*arg2);
36699
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 Py_INCREF(Py_None); resultobj = Py_None;
36704 {
36705 if (temp2)
36706 delete arg2;
36707 }
36708 return resultobj;
36709 fail:
36710 {
36711 if (temp2)
36712 delete arg2;
36713 }
36714 return NULL;
36715 }
36716
36717
36718 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36719 PyObject *resultobj;
36720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36721 wxString *result;
36722 PyObject * obj0 = 0 ;
36723 char *kwnames[] = {
36724 (char *) "self", NULL
36725 };
36726
36727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36729 if (SWIG_arg_fail(1)) SWIG_fail;
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 {
36733 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36734 result = (wxString *) &_result_ref;
36735 }
36736
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 {
36741 #if wxUSE_UNICODE
36742 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36743 #else
36744 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36745 #endif
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj;
36755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36756 wxAcceleratorEntry *result;
36757 PyObject * obj0 = 0 ;
36758 char *kwnames[] = {
36759 (char *) "self", NULL
36760 };
36761
36762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36764 if (SWIG_arg_fail(1)) SWIG_fail;
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36768
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36773 return resultobj;
36774 fail:
36775 return NULL;
36776 }
36777
36778
36779 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj;
36781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36782 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36783 PyObject * obj0 = 0 ;
36784 PyObject * obj1 = 0 ;
36785 char *kwnames[] = {
36786 (char *) "self",(char *) "accel", NULL
36787 };
36788
36789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36791 if (SWIG_arg_fail(1)) SWIG_fail;
36792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36793 if (SWIG_arg_fail(2)) SWIG_fail;
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 (arg1)->SetAccel(arg2);
36797
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 Py_INCREF(Py_None); resultobj = Py_None;
36802 return resultobj;
36803 fail:
36804 return NULL;
36805 }
36806
36807
36808 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36809 PyObject *resultobj;
36810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36811 wxFont *arg2 = 0 ;
36812 PyObject * obj0 = 0 ;
36813 PyObject * obj1 = 0 ;
36814 char *kwnames[] = {
36815 (char *) "self",(char *) "font", NULL
36816 };
36817
36818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36820 if (SWIG_arg_fail(1)) SWIG_fail;
36821 {
36822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(2)) SWIG_fail;
36824 if (arg2 == NULL) {
36825 SWIG_null_ref("wxFont");
36826 }
36827 if (SWIG_arg_fail(2)) SWIG_fail;
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 (arg1)->SetFont((wxFont const &)*arg2);
36832
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 Py_INCREF(Py_None); resultobj = Py_None;
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36844 PyObject *resultobj;
36845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36846 wxFont result;
36847 PyObject * obj0 = 0 ;
36848 char *kwnames[] = {
36849 (char *) "self", NULL
36850 };
36851
36852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36854 if (SWIG_arg_fail(1)) SWIG_fail;
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 result = (arg1)->GetFont();
36858
36859 wxPyEndAllowThreads(__tstate);
36860 if (PyErr_Occurred()) SWIG_fail;
36861 }
36862 {
36863 wxFont * resultptr;
36864 resultptr = new wxFont((wxFont &)(result));
36865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36866 }
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj;
36875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36876 wxColour *arg2 = 0 ;
36877 wxColour temp2 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char *kwnames[] = {
36881 (char *) "self",(char *) "colText", NULL
36882 };
36883
36884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36886 if (SWIG_arg_fail(1)) SWIG_fail;
36887 {
36888 arg2 = &temp2;
36889 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36890 }
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 (arg1)->SetTextColour((wxColour const &)*arg2);
36894
36895 wxPyEndAllowThreads(__tstate);
36896 if (PyErr_Occurred()) SWIG_fail;
36897 }
36898 Py_INCREF(Py_None); resultobj = Py_None;
36899 return resultobj;
36900 fail:
36901 return NULL;
36902 }
36903
36904
36905 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36906 PyObject *resultobj;
36907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36908 wxColour result;
36909 PyObject * obj0 = 0 ;
36910 char *kwnames[] = {
36911 (char *) "self", NULL
36912 };
36913
36914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36916 if (SWIG_arg_fail(1)) SWIG_fail;
36917 {
36918 PyThreadState* __tstate = wxPyBeginAllowThreads();
36919 result = (arg1)->GetTextColour();
36920
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 {
36925 wxColour * resultptr;
36926 resultptr = new wxColour((wxColour &)(result));
36927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36928 }
36929 return resultobj;
36930 fail:
36931 return NULL;
36932 }
36933
36934
36935 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36936 PyObject *resultobj;
36937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36938 wxColour *arg2 = 0 ;
36939 wxColour temp2 ;
36940 PyObject * obj0 = 0 ;
36941 PyObject * obj1 = 0 ;
36942 char *kwnames[] = {
36943 (char *) "self",(char *) "colBack", NULL
36944 };
36945
36946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36948 if (SWIG_arg_fail(1)) SWIG_fail;
36949 {
36950 arg2 = &temp2;
36951 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36952 }
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36956
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 Py_INCREF(Py_None); resultobj = Py_None;
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj;
36969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36970 wxColour result;
36971 PyObject * obj0 = 0 ;
36972 char *kwnames[] = {
36973 (char *) "self", NULL
36974 };
36975
36976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36978 if (SWIG_arg_fail(1)) SWIG_fail;
36979 {
36980 PyThreadState* __tstate = wxPyBeginAllowThreads();
36981 result = (arg1)->GetBackgroundColour();
36982
36983 wxPyEndAllowThreads(__tstate);
36984 if (PyErr_Occurred()) SWIG_fail;
36985 }
36986 {
36987 wxColour * resultptr;
36988 resultptr = new wxColour((wxColour &)(result));
36989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36990 }
36991 return resultobj;
36992 fail:
36993 return NULL;
36994 }
36995
36996
36997 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36998 PyObject *resultobj;
36999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37000 wxBitmap *arg2 = 0 ;
37001 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37002 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 PyObject * obj2 = 0 ;
37006 char *kwnames[] = {
37007 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37008 };
37009
37010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37012 if (SWIG_arg_fail(1)) SWIG_fail;
37013 {
37014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37015 if (SWIG_arg_fail(2)) SWIG_fail;
37016 if (arg2 == NULL) {
37017 SWIG_null_ref("wxBitmap");
37018 }
37019 if (SWIG_arg_fail(2)) SWIG_fail;
37020 }
37021 if (obj2) {
37022 {
37023 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37024 if (SWIG_arg_fail(3)) SWIG_fail;
37025 if (arg3 == NULL) {
37026 SWIG_null_ref("wxBitmap");
37027 }
37028 if (SWIG_arg_fail(3)) SWIG_fail;
37029 }
37030 }
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37034
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 Py_INCREF(Py_None); resultobj = Py_None;
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj;
37047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37048 wxBitmap *arg2 = 0 ;
37049 PyObject * obj0 = 0 ;
37050 PyObject * obj1 = 0 ;
37051 char *kwnames[] = {
37052 (char *) "self",(char *) "bmpDisabled", NULL
37053 };
37054
37055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37057 if (SWIG_arg_fail(1)) SWIG_fail;
37058 {
37059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37060 if (SWIG_arg_fail(2)) SWIG_fail;
37061 if (arg2 == NULL) {
37062 SWIG_null_ref("wxBitmap");
37063 }
37064 if (SWIG_arg_fail(2)) SWIG_fail;
37065 }
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37069
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 Py_INCREF(Py_None); resultobj = Py_None;
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj;
37082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37083 wxBitmap *result;
37084 PyObject * obj0 = 0 ;
37085 char *kwnames[] = {
37086 (char *) "self", NULL
37087 };
37088
37089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37091 if (SWIG_arg_fail(1)) SWIG_fail;
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 {
37095 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37096 result = (wxBitmap *) &_result_ref;
37097 }
37098
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 {
37103 wxBitmap* resultptr = new wxBitmap(*result);
37104 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37105 }
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37113 PyObject *resultobj;
37114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37115 int arg2 ;
37116 PyObject * obj0 = 0 ;
37117 PyObject * obj1 = 0 ;
37118 char *kwnames[] = {
37119 (char *) "self",(char *) "nWidth", NULL
37120 };
37121
37122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37124 if (SWIG_arg_fail(1)) SWIG_fail;
37125 {
37126 arg2 = (int)(SWIG_As_int(obj1));
37127 if (SWIG_arg_fail(2)) SWIG_fail;
37128 }
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 (arg1)->SetMarginWidth(arg2);
37132
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 Py_INCREF(Py_None); resultobj = Py_None;
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37144 PyObject *resultobj;
37145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37146 int result;
37147 PyObject * obj0 = 0 ;
37148 char *kwnames[] = {
37149 (char *) "self", NULL
37150 };
37151
37152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37154 if (SWIG_arg_fail(1)) SWIG_fail;
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 result = (int)(arg1)->GetMarginWidth();
37158
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 resultobj = SWIG_From_int((int)(result));
37164 }
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37172 PyObject *resultobj;
37173 int result;
37174 char *kwnames[] = {
37175 NULL
37176 };
37177
37178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (int)wxMenuItem::GetDefaultMarginWidth();
37182
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 {
37187 resultobj = SWIG_From_int((int)(result));
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj;
37197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37198 bool result;
37199 PyObject * obj0 = 0 ;
37200 char *kwnames[] = {
37201 (char *) "self", NULL
37202 };
37203
37204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37206 if (SWIG_arg_fail(1)) SWIG_fail;
37207 {
37208 PyThreadState* __tstate = wxPyBeginAllowThreads();
37209 result = (bool)(arg1)->IsOwnerDrawn();
37210
37211 wxPyEndAllowThreads(__tstate);
37212 if (PyErr_Occurred()) SWIG_fail;
37213 }
37214 {
37215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37216 }
37217 return resultobj;
37218 fail:
37219 return NULL;
37220 }
37221
37222
37223 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37224 PyObject *resultobj;
37225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37226 bool arg2 = (bool) true ;
37227 PyObject * obj0 = 0 ;
37228 PyObject * obj1 = 0 ;
37229 char *kwnames[] = {
37230 (char *) "self",(char *) "ownerDrawn", NULL
37231 };
37232
37233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37235 if (SWIG_arg_fail(1)) SWIG_fail;
37236 if (obj1) {
37237 {
37238 arg2 = (bool)(SWIG_As_bool(obj1));
37239 if (SWIG_arg_fail(2)) SWIG_fail;
37240 }
37241 }
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 (arg1)->SetOwnerDrawn(arg2);
37245
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 Py_INCREF(Py_None); resultobj = Py_None;
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj;
37258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37259 PyObject * obj0 = 0 ;
37260 char *kwnames[] = {
37261 (char *) "self", NULL
37262 };
37263
37264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37266 if (SWIG_arg_fail(1)) SWIG_fail;
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 (arg1)->ResetOwnerDrawn();
37270
37271 wxPyEndAllowThreads(__tstate);
37272 if (PyErr_Occurred()) SWIG_fail;
37273 }
37274 Py_INCREF(Py_None); resultobj = Py_None;
37275 return resultobj;
37276 fail:
37277 return NULL;
37278 }
37279
37280
37281 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj;
37283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37284 wxBitmap *arg2 = 0 ;
37285 PyObject * obj0 = 0 ;
37286 PyObject * obj1 = 0 ;
37287 char *kwnames[] = {
37288 (char *) "self",(char *) "bitmap", NULL
37289 };
37290
37291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37293 if (SWIG_arg_fail(1)) SWIG_fail;
37294 {
37295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37296 if (SWIG_arg_fail(2)) SWIG_fail;
37297 if (arg2 == NULL) {
37298 SWIG_null_ref("wxBitmap");
37299 }
37300 if (SWIG_arg_fail(2)) SWIG_fail;
37301 }
37302 {
37303 PyThreadState* __tstate = wxPyBeginAllowThreads();
37304 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37305
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 Py_INCREF(Py_None); resultobj = Py_None;
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37317 PyObject *resultobj;
37318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37319 wxBitmap *result;
37320 PyObject * obj0 = 0 ;
37321 char *kwnames[] = {
37322 (char *) "self", NULL
37323 };
37324
37325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37327 if (SWIG_arg_fail(1)) SWIG_fail;
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 {
37331 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37332 result = (wxBitmap *) &_result_ref;
37333 }
37334
37335 wxPyEndAllowThreads(__tstate);
37336 if (PyErr_Occurred()) SWIG_fail;
37337 }
37338 {
37339 wxBitmap* resultptr = new wxBitmap(*result);
37340 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37341 }
37342 return resultobj;
37343 fail:
37344 return NULL;
37345 }
37346
37347
37348 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37349 PyObject *obj;
37350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37351 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37352 Py_INCREF(obj);
37353 return Py_BuildValue((char *)"");
37354 }
37355 static int _wrap_ControlNameStr_set(PyObject *) {
37356 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37357 return 1;
37358 }
37359
37360
37361 static PyObject *_wrap_ControlNameStr_get(void) {
37362 PyObject *pyobj;
37363
37364 {
37365 #if wxUSE_UNICODE
37366 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37367 #else
37368 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37369 #endif
37370 }
37371 return pyobj;
37372 }
37373
37374
37375 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj;
37377 wxWindow *arg1 = (wxWindow *) 0 ;
37378 int arg2 = (int) -1 ;
37379 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37380 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37381 wxSize const &arg4_defvalue = wxDefaultSize ;
37382 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37383 long arg5 = (long) 0 ;
37384 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37385 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37386 wxString const &arg7_defvalue = wxPyControlNameStr ;
37387 wxString *arg7 = (wxString *) &arg7_defvalue ;
37388 wxControl *result;
37389 wxPoint temp3 ;
37390 wxSize temp4 ;
37391 bool temp7 = false ;
37392 PyObject * obj0 = 0 ;
37393 PyObject * obj1 = 0 ;
37394 PyObject * obj2 = 0 ;
37395 PyObject * obj3 = 0 ;
37396 PyObject * obj4 = 0 ;
37397 PyObject * obj5 = 0 ;
37398 PyObject * obj6 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 if (obj1) {
37407 {
37408 arg2 = (int)(SWIG_As_int(obj1));
37409 if (SWIG_arg_fail(2)) SWIG_fail;
37410 }
37411 }
37412 if (obj2) {
37413 {
37414 arg3 = &temp3;
37415 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37416 }
37417 }
37418 if (obj3) {
37419 {
37420 arg4 = &temp4;
37421 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37422 }
37423 }
37424 if (obj4) {
37425 {
37426 arg5 = (long)(SWIG_As_long(obj4));
37427 if (SWIG_arg_fail(5)) SWIG_fail;
37428 }
37429 }
37430 if (obj5) {
37431 {
37432 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37433 if (SWIG_arg_fail(6)) SWIG_fail;
37434 if (arg6 == NULL) {
37435 SWIG_null_ref("wxValidator");
37436 }
37437 if (SWIG_arg_fail(6)) SWIG_fail;
37438 }
37439 }
37440 if (obj6) {
37441 {
37442 arg7 = wxString_in_helper(obj6);
37443 if (arg7 == NULL) SWIG_fail;
37444 temp7 = true;
37445 }
37446 }
37447 {
37448 if (!wxPyCheckForApp()) SWIG_fail;
37449 PyThreadState* __tstate = wxPyBeginAllowThreads();
37450 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37451
37452 wxPyEndAllowThreads(__tstate);
37453 if (PyErr_Occurred()) SWIG_fail;
37454 }
37455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37456 {
37457 if (temp7)
37458 delete arg7;
37459 }
37460 return resultobj;
37461 fail:
37462 {
37463 if (temp7)
37464 delete arg7;
37465 }
37466 return NULL;
37467 }
37468
37469
37470 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37471 PyObject *resultobj;
37472 wxControl *result;
37473 char *kwnames[] = {
37474 NULL
37475 };
37476
37477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37478 {
37479 if (!wxPyCheckForApp()) SWIG_fail;
37480 PyThreadState* __tstate = wxPyBeginAllowThreads();
37481 result = (wxControl *)new wxControl();
37482
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37487 return resultobj;
37488 fail:
37489 return NULL;
37490 }
37491
37492
37493 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37494 PyObject *resultobj;
37495 wxControl *arg1 = (wxControl *) 0 ;
37496 wxWindow *arg2 = (wxWindow *) 0 ;
37497 int arg3 = (int) -1 ;
37498 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37499 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37500 wxSize const &arg5_defvalue = wxDefaultSize ;
37501 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37502 long arg6 = (long) 0 ;
37503 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37504 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37505 wxString const &arg8_defvalue = wxPyControlNameStr ;
37506 wxString *arg8 = (wxString *) &arg8_defvalue ;
37507 bool result;
37508 wxPoint temp4 ;
37509 wxSize temp5 ;
37510 bool temp8 = false ;
37511 PyObject * obj0 = 0 ;
37512 PyObject * obj1 = 0 ;
37513 PyObject * obj2 = 0 ;
37514 PyObject * obj3 = 0 ;
37515 PyObject * obj4 = 0 ;
37516 PyObject * obj5 = 0 ;
37517 PyObject * obj6 = 0 ;
37518 PyObject * obj7 = 0 ;
37519 char *kwnames[] = {
37520 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37521 };
37522
37523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37525 if (SWIG_arg_fail(1)) SWIG_fail;
37526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37527 if (SWIG_arg_fail(2)) SWIG_fail;
37528 if (obj2) {
37529 {
37530 arg3 = (int)(SWIG_As_int(obj2));
37531 if (SWIG_arg_fail(3)) SWIG_fail;
37532 }
37533 }
37534 if (obj3) {
37535 {
37536 arg4 = &temp4;
37537 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37538 }
37539 }
37540 if (obj4) {
37541 {
37542 arg5 = &temp5;
37543 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37544 }
37545 }
37546 if (obj5) {
37547 {
37548 arg6 = (long)(SWIG_As_long(obj5));
37549 if (SWIG_arg_fail(6)) SWIG_fail;
37550 }
37551 }
37552 if (obj6) {
37553 {
37554 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37555 if (SWIG_arg_fail(7)) SWIG_fail;
37556 if (arg7 == NULL) {
37557 SWIG_null_ref("wxValidator");
37558 }
37559 if (SWIG_arg_fail(7)) SWIG_fail;
37560 }
37561 }
37562 if (obj7) {
37563 {
37564 arg8 = wxString_in_helper(obj7);
37565 if (arg8 == NULL) SWIG_fail;
37566 temp8 = true;
37567 }
37568 }
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37572
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 {
37577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37578 }
37579 {
37580 if (temp8)
37581 delete arg8;
37582 }
37583 return resultobj;
37584 fail:
37585 {
37586 if (temp8)
37587 delete arg8;
37588 }
37589 return NULL;
37590 }
37591
37592
37593 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37594 PyObject *resultobj;
37595 wxControl *arg1 = (wxControl *) 0 ;
37596 wxCommandEvent *arg2 = 0 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char *kwnames[] = {
37600 (char *) "self",(char *) "event", NULL
37601 };
37602
37603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37605 if (SWIG_arg_fail(1)) SWIG_fail;
37606 {
37607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37608 if (SWIG_arg_fail(2)) SWIG_fail;
37609 if (arg2 == NULL) {
37610 SWIG_null_ref("wxCommandEvent");
37611 }
37612 if (SWIG_arg_fail(2)) SWIG_fail;
37613 }
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->Command(*arg2);
37617
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 Py_INCREF(Py_None); resultobj = Py_None;
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37629 PyObject *resultobj;
37630 wxControl *arg1 = (wxControl *) 0 ;
37631 wxString result;
37632 PyObject * obj0 = 0 ;
37633 char *kwnames[] = {
37634 (char *) "self", NULL
37635 };
37636
37637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37639 if (SWIG_arg_fail(1)) SWIG_fail;
37640 {
37641 PyThreadState* __tstate = wxPyBeginAllowThreads();
37642 result = (arg1)->GetLabel();
37643
37644 wxPyEndAllowThreads(__tstate);
37645 if (PyErr_Occurred()) SWIG_fail;
37646 }
37647 {
37648 #if wxUSE_UNICODE
37649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37650 #else
37651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37652 #endif
37653 }
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj;
37662 wxControl *arg1 = (wxControl *) 0 ;
37663 wxString *arg2 = 0 ;
37664 bool temp2 = false ;
37665 PyObject * obj0 = 0 ;
37666 PyObject * obj1 = 0 ;
37667 char *kwnames[] = {
37668 (char *) "self",(char *) "label", NULL
37669 };
37670
37671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37673 if (SWIG_arg_fail(1)) SWIG_fail;
37674 {
37675 arg2 = wxString_in_helper(obj1);
37676 if (arg2 == NULL) SWIG_fail;
37677 temp2 = true;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->SetLabel((wxString const &)*arg2);
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 Py_INCREF(Py_None); resultobj = Py_None;
37687 {
37688 if (temp2)
37689 delete arg2;
37690 }
37691 return resultobj;
37692 fail:
37693 {
37694 if (temp2)
37695 delete arg2;
37696 }
37697 return NULL;
37698 }
37699
37700
37701 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37702 PyObject *resultobj;
37703 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37704 wxVisualAttributes result;
37705 PyObject * obj0 = 0 ;
37706 char *kwnames[] = {
37707 (char *) "variant", NULL
37708 };
37709
37710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37711 if (obj0) {
37712 {
37713 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37714 if (SWIG_arg_fail(1)) SWIG_fail;
37715 }
37716 }
37717 {
37718 if (!wxPyCheckForApp()) SWIG_fail;
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 {
37726 wxVisualAttributes * resultptr;
37727 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37729 }
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37737 PyObject *obj;
37738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37739 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37740 Py_INCREF(obj);
37741 return Py_BuildValue((char *)"");
37742 }
37743 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj;
37745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37746 wxString *arg2 = 0 ;
37747 PyObject *arg3 = (PyObject *) NULL ;
37748 int result;
37749 bool temp2 = false ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 PyObject * obj2 = 0 ;
37753 char *kwnames[] = {
37754 (char *) "self",(char *) "item",(char *) "clientData", NULL
37755 };
37756
37757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37759 if (SWIG_arg_fail(1)) SWIG_fail;
37760 {
37761 arg2 = wxString_in_helper(obj1);
37762 if (arg2 == NULL) SWIG_fail;
37763 temp2 = true;
37764 }
37765 if (obj2) {
37766 arg3 = obj2;
37767 }
37768 {
37769 PyThreadState* __tstate = wxPyBeginAllowThreads();
37770 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37771
37772 wxPyEndAllowThreads(__tstate);
37773 if (PyErr_Occurred()) SWIG_fail;
37774 }
37775 {
37776 resultobj = SWIG_From_int((int)(result));
37777 }
37778 {
37779 if (temp2)
37780 delete arg2;
37781 }
37782 return resultobj;
37783 fail:
37784 {
37785 if (temp2)
37786 delete arg2;
37787 }
37788 return NULL;
37789 }
37790
37791
37792 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37793 PyObject *resultobj;
37794 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37795 wxArrayString *arg2 = 0 ;
37796 bool temp2 = false ;
37797 PyObject * obj0 = 0 ;
37798 PyObject * obj1 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self",(char *) "strings", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 if (! PySequence_Check(obj1)) {
37808 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37809 SWIG_fail;
37810 }
37811 arg2 = new wxArrayString;
37812 temp2 = true;
37813 int i, len=PySequence_Length(obj1);
37814 for (i=0; i<len; i++) {
37815 PyObject* item = PySequence_GetItem(obj1, i);
37816 #if wxUSE_UNICODE
37817 PyObject* str = PyObject_Unicode(item);
37818 #else
37819 PyObject* str = PyObject_Str(item);
37820 #endif
37821 if (PyErr_Occurred()) SWIG_fail;
37822 arg2->Add(Py2wxString(str));
37823 Py_DECREF(item);
37824 Py_DECREF(str);
37825 }
37826 }
37827 {
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 (arg1)->Append((wxArrayString const &)*arg2);
37830
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 Py_INCREF(Py_None); resultobj = Py_None;
37835 {
37836 if (temp2) delete arg2;
37837 }
37838 return resultobj;
37839 fail:
37840 {
37841 if (temp2) delete arg2;
37842 }
37843 return NULL;
37844 }
37845
37846
37847 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37848 PyObject *resultobj;
37849 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37850 wxString *arg2 = 0 ;
37851 int arg3 ;
37852 PyObject *arg4 = (PyObject *) NULL ;
37853 int result;
37854 bool temp2 = false ;
37855 PyObject * obj0 = 0 ;
37856 PyObject * obj1 = 0 ;
37857 PyObject * obj2 = 0 ;
37858 PyObject * obj3 = 0 ;
37859 char *kwnames[] = {
37860 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37861 };
37862
37863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37865 if (SWIG_arg_fail(1)) SWIG_fail;
37866 {
37867 arg2 = wxString_in_helper(obj1);
37868 if (arg2 == NULL) SWIG_fail;
37869 temp2 = true;
37870 }
37871 {
37872 arg3 = (int)(SWIG_As_int(obj2));
37873 if (SWIG_arg_fail(3)) SWIG_fail;
37874 }
37875 if (obj3) {
37876 arg4 = obj3;
37877 }
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37881
37882 wxPyEndAllowThreads(__tstate);
37883 if (PyErr_Occurred()) SWIG_fail;
37884 }
37885 {
37886 resultobj = SWIG_From_int((int)(result));
37887 }
37888 {
37889 if (temp2)
37890 delete arg2;
37891 }
37892 return resultobj;
37893 fail:
37894 {
37895 if (temp2)
37896 delete arg2;
37897 }
37898 return NULL;
37899 }
37900
37901
37902 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37903 PyObject *resultobj;
37904 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37905 PyObject * obj0 = 0 ;
37906 char *kwnames[] = {
37907 (char *) "self", NULL
37908 };
37909
37910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37912 if (SWIG_arg_fail(1)) SWIG_fail;
37913 {
37914 PyThreadState* __tstate = wxPyBeginAllowThreads();
37915 (arg1)->Clear();
37916
37917 wxPyEndAllowThreads(__tstate);
37918 if (PyErr_Occurred()) SWIG_fail;
37919 }
37920 Py_INCREF(Py_None); resultobj = Py_None;
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37928 PyObject *resultobj;
37929 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37930 int arg2 ;
37931 PyObject * obj0 = 0 ;
37932 PyObject * obj1 = 0 ;
37933 char *kwnames[] = {
37934 (char *) "self",(char *) "n", NULL
37935 };
37936
37937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37939 if (SWIG_arg_fail(1)) SWIG_fail;
37940 {
37941 arg2 = (int)(SWIG_As_int(obj1));
37942 if (SWIG_arg_fail(2)) SWIG_fail;
37943 }
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 (arg1)->Delete(arg2);
37947
37948 wxPyEndAllowThreads(__tstate);
37949 if (PyErr_Occurred()) SWIG_fail;
37950 }
37951 Py_INCREF(Py_None); resultobj = Py_None;
37952 return resultobj;
37953 fail:
37954 return NULL;
37955 }
37956
37957
37958 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37959 PyObject *resultobj;
37960 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37961 int arg2 ;
37962 PyObject *result;
37963 PyObject * obj0 = 0 ;
37964 PyObject * obj1 = 0 ;
37965 char *kwnames[] = {
37966 (char *) "self",(char *) "n", NULL
37967 };
37968
37969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37971 if (SWIG_arg_fail(1)) SWIG_fail;
37972 {
37973 arg2 = (int)(SWIG_As_int(obj1));
37974 if (SWIG_arg_fail(2)) SWIG_fail;
37975 }
37976 {
37977 PyThreadState* __tstate = wxPyBeginAllowThreads();
37978 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37979
37980 wxPyEndAllowThreads(__tstate);
37981 if (PyErr_Occurred()) SWIG_fail;
37982 }
37983 resultobj = result;
37984 return resultobj;
37985 fail:
37986 return NULL;
37987 }
37988
37989
37990 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37991 PyObject *resultobj;
37992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37993 int arg2 ;
37994 PyObject *arg3 = (PyObject *) 0 ;
37995 PyObject * obj0 = 0 ;
37996 PyObject * obj1 = 0 ;
37997 PyObject * obj2 = 0 ;
37998 char *kwnames[] = {
37999 (char *) "self",(char *) "n",(char *) "clientData", NULL
38000 };
38001
38002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38004 if (SWIG_arg_fail(1)) SWIG_fail;
38005 {
38006 arg2 = (int)(SWIG_As_int(obj1));
38007 if (SWIG_arg_fail(2)) SWIG_fail;
38008 }
38009 arg3 = obj2;
38010 {
38011 PyThreadState* __tstate = wxPyBeginAllowThreads();
38012 wxItemContainer_SetClientData(arg1,arg2,arg3);
38013
38014 wxPyEndAllowThreads(__tstate);
38015 if (PyErr_Occurred()) SWIG_fail;
38016 }
38017 Py_INCREF(Py_None); resultobj = Py_None;
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38025 PyObject *resultobj;
38026 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38027 int result;
38028 PyObject * obj0 = 0 ;
38029 char *kwnames[] = {
38030 (char *) "self", NULL
38031 };
38032
38033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38035 if (SWIG_arg_fail(1)) SWIG_fail;
38036 {
38037 PyThreadState* __tstate = wxPyBeginAllowThreads();
38038 result = (int)((wxItemContainer const *)arg1)->GetCount();
38039
38040 wxPyEndAllowThreads(__tstate);
38041 if (PyErr_Occurred()) SWIG_fail;
38042 }
38043 {
38044 resultobj = SWIG_From_int((int)(result));
38045 }
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38053 PyObject *resultobj;
38054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38055 bool result;
38056 PyObject * obj0 = 0 ;
38057 char *kwnames[] = {
38058 (char *) "self", NULL
38059 };
38060
38061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38063 if (SWIG_arg_fail(1)) SWIG_fail;
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38067
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 {
38072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38073 }
38074 return resultobj;
38075 fail:
38076 return NULL;
38077 }
38078
38079
38080 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38081 PyObject *resultobj;
38082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38083 int arg2 ;
38084 wxString result;
38085 PyObject * obj0 = 0 ;
38086 PyObject * obj1 = 0 ;
38087 char *kwnames[] = {
38088 (char *) "self",(char *) "n", NULL
38089 };
38090
38091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38093 if (SWIG_arg_fail(1)) SWIG_fail;
38094 {
38095 arg2 = (int)(SWIG_As_int(obj1));
38096 if (SWIG_arg_fail(2)) SWIG_fail;
38097 }
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38101
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 #if wxUSE_UNICODE
38107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38108 #else
38109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38110 #endif
38111 }
38112 return resultobj;
38113 fail:
38114 return NULL;
38115 }
38116
38117
38118 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38119 PyObject *resultobj;
38120 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38121 wxArrayString result;
38122 PyObject * obj0 = 0 ;
38123 char *kwnames[] = {
38124 (char *) "self", NULL
38125 };
38126
38127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38129 if (SWIG_arg_fail(1)) SWIG_fail;
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 result = ((wxItemContainer const *)arg1)->GetStrings();
38133
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 {
38138 resultobj = wxArrayString2PyList_helper(result);
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj;
38148 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38149 int arg2 ;
38150 wxString *arg3 = 0 ;
38151 bool temp3 = false ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 PyObject * obj2 = 0 ;
38155 char *kwnames[] = {
38156 (char *) "self",(char *) "n",(char *) "s", NULL
38157 };
38158
38159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38161 if (SWIG_arg_fail(1)) SWIG_fail;
38162 {
38163 arg2 = (int)(SWIG_As_int(obj1));
38164 if (SWIG_arg_fail(2)) SWIG_fail;
38165 }
38166 {
38167 arg3 = wxString_in_helper(obj2);
38168 if (arg3 == NULL) SWIG_fail;
38169 temp3 = true;
38170 }
38171 {
38172 PyThreadState* __tstate = wxPyBeginAllowThreads();
38173 (arg1)->SetString(arg2,(wxString const &)*arg3);
38174
38175 wxPyEndAllowThreads(__tstate);
38176 if (PyErr_Occurred()) SWIG_fail;
38177 }
38178 Py_INCREF(Py_None); resultobj = Py_None;
38179 {
38180 if (temp3)
38181 delete arg3;
38182 }
38183 return resultobj;
38184 fail:
38185 {
38186 if (temp3)
38187 delete arg3;
38188 }
38189 return NULL;
38190 }
38191
38192
38193 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38194 PyObject *resultobj;
38195 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38196 wxString *arg2 = 0 ;
38197 int result;
38198 bool temp2 = false ;
38199 PyObject * obj0 = 0 ;
38200 PyObject * obj1 = 0 ;
38201 char *kwnames[] = {
38202 (char *) "self",(char *) "s", NULL
38203 };
38204
38205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38207 if (SWIG_arg_fail(1)) SWIG_fail;
38208 {
38209 arg2 = wxString_in_helper(obj1);
38210 if (arg2 == NULL) SWIG_fail;
38211 temp2 = true;
38212 }
38213 {
38214 PyThreadState* __tstate = wxPyBeginAllowThreads();
38215 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38216
38217 wxPyEndAllowThreads(__tstate);
38218 if (PyErr_Occurred()) SWIG_fail;
38219 }
38220 {
38221 resultobj = SWIG_From_int((int)(result));
38222 }
38223 {
38224 if (temp2)
38225 delete arg2;
38226 }
38227 return resultobj;
38228 fail:
38229 {
38230 if (temp2)
38231 delete arg2;
38232 }
38233 return NULL;
38234 }
38235
38236
38237 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38238 PyObject *resultobj;
38239 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38240 int arg2 ;
38241 PyObject * obj0 = 0 ;
38242 PyObject * obj1 = 0 ;
38243 char *kwnames[] = {
38244 (char *) "self",(char *) "n", NULL
38245 };
38246
38247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38249 if (SWIG_arg_fail(1)) SWIG_fail;
38250 {
38251 arg2 = (int)(SWIG_As_int(obj1));
38252 if (SWIG_arg_fail(2)) SWIG_fail;
38253 }
38254 {
38255 PyThreadState* __tstate = wxPyBeginAllowThreads();
38256 (arg1)->SetSelection(arg2);
38257
38258 wxPyEndAllowThreads(__tstate);
38259 if (PyErr_Occurred()) SWIG_fail;
38260 }
38261 Py_INCREF(Py_None); resultobj = Py_None;
38262 return resultobj;
38263 fail:
38264 return NULL;
38265 }
38266
38267
38268 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38269 PyObject *resultobj;
38270 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38271 int result;
38272 PyObject * obj0 = 0 ;
38273 char *kwnames[] = {
38274 (char *) "self", NULL
38275 };
38276
38277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38279 if (SWIG_arg_fail(1)) SWIG_fail;
38280 {
38281 PyThreadState* __tstate = wxPyBeginAllowThreads();
38282 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38283
38284 wxPyEndAllowThreads(__tstate);
38285 if (PyErr_Occurred()) SWIG_fail;
38286 }
38287 {
38288 resultobj = SWIG_From_int((int)(result));
38289 }
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38297 PyObject *resultobj;
38298 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38299 wxString *arg2 = 0 ;
38300 bool result;
38301 bool temp2 = false ;
38302 PyObject * obj0 = 0 ;
38303 PyObject * obj1 = 0 ;
38304 char *kwnames[] = {
38305 (char *) "self",(char *) "s", NULL
38306 };
38307
38308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38310 if (SWIG_arg_fail(1)) SWIG_fail;
38311 {
38312 arg2 = wxString_in_helper(obj1);
38313 if (arg2 == NULL) SWIG_fail;
38314 temp2 = true;
38315 }
38316 {
38317 PyThreadState* __tstate = wxPyBeginAllowThreads();
38318 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38319
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38325 }
38326 {
38327 if (temp2)
38328 delete arg2;
38329 }
38330 return resultobj;
38331 fail:
38332 {
38333 if (temp2)
38334 delete arg2;
38335 }
38336 return NULL;
38337 }
38338
38339
38340 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38341 PyObject *resultobj;
38342 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38343 wxString result;
38344 PyObject * obj0 = 0 ;
38345 char *kwnames[] = {
38346 (char *) "self", NULL
38347 };
38348
38349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38351 if (SWIG_arg_fail(1)) SWIG_fail;
38352 {
38353 PyThreadState* __tstate = wxPyBeginAllowThreads();
38354 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38355
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 {
38360 #if wxUSE_UNICODE
38361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38362 #else
38363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38364 #endif
38365 }
38366 return resultobj;
38367 fail:
38368 return NULL;
38369 }
38370
38371
38372 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38373 PyObject *resultobj;
38374 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38375 int arg2 ;
38376 PyObject * obj0 = 0 ;
38377 PyObject * obj1 = 0 ;
38378 char *kwnames[] = {
38379 (char *) "self",(char *) "n", NULL
38380 };
38381
38382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38384 if (SWIG_arg_fail(1)) SWIG_fail;
38385 {
38386 arg2 = (int)(SWIG_As_int(obj1));
38387 if (SWIG_arg_fail(2)) SWIG_fail;
38388 }
38389 {
38390 PyThreadState* __tstate = wxPyBeginAllowThreads();
38391 (arg1)->Select(arg2);
38392
38393 wxPyEndAllowThreads(__tstate);
38394 if (PyErr_Occurred()) SWIG_fail;
38395 }
38396 Py_INCREF(Py_None); resultobj = Py_None;
38397 return resultobj;
38398 fail:
38399 return NULL;
38400 }
38401
38402
38403 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38404 PyObject *obj;
38405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38406 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38407 Py_INCREF(obj);
38408 return Py_BuildValue((char *)"");
38409 }
38410 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38411 PyObject *obj;
38412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38413 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38414 Py_INCREF(obj);
38415 return Py_BuildValue((char *)"");
38416 }
38417 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38418 PyObject *resultobj;
38419 wxSizerItem *result;
38420 char *kwnames[] = {
38421 NULL
38422 };
38423
38424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 result = (wxSizerItem *)new wxSizerItem();
38428
38429 wxPyEndAllowThreads(__tstate);
38430 if (PyErr_Occurred()) SWIG_fail;
38431 }
38432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38433 return resultobj;
38434 fail:
38435 return NULL;
38436 }
38437
38438
38439 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38440 PyObject *resultobj;
38441 wxWindow *arg1 = (wxWindow *) 0 ;
38442 int arg2 ;
38443 int arg3 ;
38444 int arg4 ;
38445 PyObject *arg5 = (PyObject *) NULL ;
38446 wxSizerItem *result;
38447 PyObject * obj0 = 0 ;
38448 PyObject * obj1 = 0 ;
38449 PyObject * obj2 = 0 ;
38450 PyObject * obj3 = 0 ;
38451 PyObject * obj4 = 0 ;
38452 char *kwnames[] = {
38453 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38454 };
38455
38456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38458 if (SWIG_arg_fail(1)) SWIG_fail;
38459 {
38460 arg2 = (int)(SWIG_As_int(obj1));
38461 if (SWIG_arg_fail(2)) SWIG_fail;
38462 }
38463 {
38464 arg3 = (int)(SWIG_As_int(obj2));
38465 if (SWIG_arg_fail(3)) SWIG_fail;
38466 }
38467 {
38468 arg4 = (int)(SWIG_As_int(obj3));
38469 if (SWIG_arg_fail(4)) SWIG_fail;
38470 }
38471 if (obj4) {
38472 arg5 = obj4;
38473 }
38474 {
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38477
38478 wxPyEndAllowThreads(__tstate);
38479 if (PyErr_Occurred()) SWIG_fail;
38480 }
38481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38482 return resultobj;
38483 fail:
38484 return NULL;
38485 }
38486
38487
38488 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38489 PyObject *resultobj;
38490 int arg1 ;
38491 int arg2 ;
38492 int arg3 ;
38493 int arg4 ;
38494 int arg5 ;
38495 PyObject *arg6 = (PyObject *) NULL ;
38496 wxSizerItem *result;
38497 PyObject * obj0 = 0 ;
38498 PyObject * obj1 = 0 ;
38499 PyObject * obj2 = 0 ;
38500 PyObject * obj3 = 0 ;
38501 PyObject * obj4 = 0 ;
38502 PyObject * obj5 = 0 ;
38503 char *kwnames[] = {
38504 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38505 };
38506
38507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38508 {
38509 arg1 = (int)(SWIG_As_int(obj0));
38510 if (SWIG_arg_fail(1)) SWIG_fail;
38511 }
38512 {
38513 arg2 = (int)(SWIG_As_int(obj1));
38514 if (SWIG_arg_fail(2)) SWIG_fail;
38515 }
38516 {
38517 arg3 = (int)(SWIG_As_int(obj2));
38518 if (SWIG_arg_fail(3)) SWIG_fail;
38519 }
38520 {
38521 arg4 = (int)(SWIG_As_int(obj3));
38522 if (SWIG_arg_fail(4)) SWIG_fail;
38523 }
38524 {
38525 arg5 = (int)(SWIG_As_int(obj4));
38526 if (SWIG_arg_fail(5)) SWIG_fail;
38527 }
38528 if (obj5) {
38529 arg6 = obj5;
38530 }
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38534
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38539 return resultobj;
38540 fail:
38541 return NULL;
38542 }
38543
38544
38545 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38546 PyObject *resultobj;
38547 wxSizer *arg1 = (wxSizer *) 0 ;
38548 int arg2 ;
38549 int arg3 ;
38550 int arg4 ;
38551 PyObject *arg5 = (PyObject *) NULL ;
38552 wxSizerItem *result;
38553 PyObject * obj0 = 0 ;
38554 PyObject * obj1 = 0 ;
38555 PyObject * obj2 = 0 ;
38556 PyObject * obj3 = 0 ;
38557 PyObject * obj4 = 0 ;
38558 char *kwnames[] = {
38559 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38560 };
38561
38562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38564 if (SWIG_arg_fail(1)) SWIG_fail;
38565 {
38566 arg2 = (int)(SWIG_As_int(obj1));
38567 if (SWIG_arg_fail(2)) SWIG_fail;
38568 }
38569 {
38570 arg3 = (int)(SWIG_As_int(obj2));
38571 if (SWIG_arg_fail(3)) SWIG_fail;
38572 }
38573 {
38574 arg4 = (int)(SWIG_As_int(obj3));
38575 if (SWIG_arg_fail(4)) SWIG_fail;
38576 }
38577 if (obj4) {
38578 arg5 = obj4;
38579 }
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38583
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj;
38596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38597 PyObject * obj0 = 0 ;
38598 char *kwnames[] = {
38599 (char *) "self", NULL
38600 };
38601
38602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38604 if (SWIG_arg_fail(1)) SWIG_fail;
38605 {
38606 PyThreadState* __tstate = wxPyBeginAllowThreads();
38607 (arg1)->DeleteWindows();
38608
38609 wxPyEndAllowThreads(__tstate);
38610 if (PyErr_Occurred()) SWIG_fail;
38611 }
38612 Py_INCREF(Py_None); resultobj = Py_None;
38613 return resultobj;
38614 fail:
38615 return NULL;
38616 }
38617
38618
38619 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38620 PyObject *resultobj;
38621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38622 PyObject * obj0 = 0 ;
38623 char *kwnames[] = {
38624 (char *) "self", NULL
38625 };
38626
38627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38629 if (SWIG_arg_fail(1)) SWIG_fail;
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 (arg1)->DetachSizer();
38633
38634 wxPyEndAllowThreads(__tstate);
38635 if (PyErr_Occurred()) SWIG_fail;
38636 }
38637 Py_INCREF(Py_None); resultobj = Py_None;
38638 return resultobj;
38639 fail:
38640 return NULL;
38641 }
38642
38643
38644 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38645 PyObject *resultobj;
38646 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38647 wxSize result;
38648 PyObject * obj0 = 0 ;
38649 char *kwnames[] = {
38650 (char *) "self", NULL
38651 };
38652
38653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38655 if (SWIG_arg_fail(1)) SWIG_fail;
38656 {
38657 PyThreadState* __tstate = wxPyBeginAllowThreads();
38658 result = (arg1)->GetSize();
38659
38660 wxPyEndAllowThreads(__tstate);
38661 if (PyErr_Occurred()) SWIG_fail;
38662 }
38663 {
38664 wxSize * resultptr;
38665 resultptr = new wxSize((wxSize &)(result));
38666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38667 }
38668 return resultobj;
38669 fail:
38670 return NULL;
38671 }
38672
38673
38674 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38675 PyObject *resultobj;
38676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38677 wxSize result;
38678 PyObject * obj0 = 0 ;
38679 char *kwnames[] = {
38680 (char *) "self", NULL
38681 };
38682
38683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38685 if (SWIG_arg_fail(1)) SWIG_fail;
38686 {
38687 PyThreadState* __tstate = wxPyBeginAllowThreads();
38688 result = (arg1)->CalcMin();
38689
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 {
38694 wxSize * resultptr;
38695 resultptr = new wxSize((wxSize &)(result));
38696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38697 }
38698 return resultobj;
38699 fail:
38700 return NULL;
38701 }
38702
38703
38704 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38705 PyObject *resultobj;
38706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38707 wxPoint arg2 ;
38708 wxSize arg3 ;
38709 PyObject * obj0 = 0 ;
38710 PyObject * obj1 = 0 ;
38711 PyObject * obj2 = 0 ;
38712 char *kwnames[] = {
38713 (char *) "self",(char *) "pos",(char *) "size", NULL
38714 };
38715
38716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38718 if (SWIG_arg_fail(1)) SWIG_fail;
38719 {
38720 wxPoint * argp;
38721 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38722 if (SWIG_arg_fail(2)) SWIG_fail;
38723 if (argp == NULL) {
38724 SWIG_null_ref("wxPoint");
38725 }
38726 if (SWIG_arg_fail(2)) SWIG_fail;
38727 arg2 = *argp;
38728 }
38729 {
38730 wxSize * argp;
38731 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38732 if (SWIG_arg_fail(3)) SWIG_fail;
38733 if (argp == NULL) {
38734 SWIG_null_ref("wxSize");
38735 }
38736 if (SWIG_arg_fail(3)) SWIG_fail;
38737 arg3 = *argp;
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 (arg1)->SetDimension(arg2,arg3);
38742
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 Py_INCREF(Py_None); resultobj = Py_None;
38747 return resultobj;
38748 fail:
38749 return NULL;
38750 }
38751
38752
38753 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38754 PyObject *resultobj;
38755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38756 wxSize result;
38757 PyObject * obj0 = 0 ;
38758 char *kwnames[] = {
38759 (char *) "self", NULL
38760 };
38761
38762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38764 if (SWIG_arg_fail(1)) SWIG_fail;
38765 {
38766 PyThreadState* __tstate = wxPyBeginAllowThreads();
38767 result = (arg1)->GetMinSize();
38768
38769 wxPyEndAllowThreads(__tstate);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 }
38772 {
38773 wxSize * resultptr;
38774 resultptr = new wxSize((wxSize &)(result));
38775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38784 PyObject *resultobj;
38785 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38786 wxSize result;
38787 PyObject * obj0 = 0 ;
38788 char *kwnames[] = {
38789 (char *) "self", NULL
38790 };
38791
38792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38794 if (SWIG_arg_fail(1)) SWIG_fail;
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38798
38799 wxPyEndAllowThreads(__tstate);
38800 if (PyErr_Occurred()) SWIG_fail;
38801 }
38802 {
38803 wxSize * resultptr;
38804 resultptr = new wxSize((wxSize &)(result));
38805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38806 }
38807 return resultobj;
38808 fail:
38809 return NULL;
38810 }
38811
38812
38813 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38814 PyObject *resultobj;
38815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38816 int arg2 ;
38817 int arg3 ;
38818 PyObject * obj0 = 0 ;
38819 PyObject * obj1 = 0 ;
38820 PyObject * obj2 = 0 ;
38821 char *kwnames[] = {
38822 (char *) "self",(char *) "x",(char *) "y", NULL
38823 };
38824
38825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38827 if (SWIG_arg_fail(1)) SWIG_fail;
38828 {
38829 arg2 = (int)(SWIG_As_int(obj1));
38830 if (SWIG_arg_fail(2)) SWIG_fail;
38831 }
38832 {
38833 arg3 = (int)(SWIG_As_int(obj2));
38834 if (SWIG_arg_fail(3)) SWIG_fail;
38835 }
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 (arg1)->SetInitSize(arg2,arg3);
38839
38840 wxPyEndAllowThreads(__tstate);
38841 if (PyErr_Occurred()) SWIG_fail;
38842 }
38843 Py_INCREF(Py_None); resultobj = Py_None;
38844 return resultobj;
38845 fail:
38846 return NULL;
38847 }
38848
38849
38850 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38851 PyObject *resultobj;
38852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38853 int arg2 ;
38854 int arg3 ;
38855 PyObject * obj0 = 0 ;
38856 PyObject * obj1 = 0 ;
38857 PyObject * obj2 = 0 ;
38858 char *kwnames[] = {
38859 (char *) "self",(char *) "width",(char *) "height", NULL
38860 };
38861
38862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38864 if (SWIG_arg_fail(1)) SWIG_fail;
38865 {
38866 arg2 = (int)(SWIG_As_int(obj1));
38867 if (SWIG_arg_fail(2)) SWIG_fail;
38868 }
38869 {
38870 arg3 = (int)(SWIG_As_int(obj2));
38871 if (SWIG_arg_fail(3)) SWIG_fail;
38872 }
38873 {
38874 PyThreadState* __tstate = wxPyBeginAllowThreads();
38875 (arg1)->SetRatio(arg2,arg3);
38876
38877 wxPyEndAllowThreads(__tstate);
38878 if (PyErr_Occurred()) SWIG_fail;
38879 }
38880 Py_INCREF(Py_None); resultobj = Py_None;
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38888 PyObject *resultobj;
38889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38890 wxSize *arg2 = 0 ;
38891 wxSize temp2 ;
38892 PyObject * obj0 = 0 ;
38893 PyObject * obj1 = 0 ;
38894 char *kwnames[] = {
38895 (char *) "self",(char *) "size", NULL
38896 };
38897
38898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38900 if (SWIG_arg_fail(1)) SWIG_fail;
38901 {
38902 arg2 = &temp2;
38903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38904 }
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 (arg1)->SetRatio((wxSize const &)*arg2);
38908
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 Py_INCREF(Py_None); resultobj = Py_None;
38913 return resultobj;
38914 fail:
38915 return NULL;
38916 }
38917
38918
38919 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38920 PyObject *resultobj;
38921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38922 float arg2 ;
38923 PyObject * obj0 = 0 ;
38924 PyObject * obj1 = 0 ;
38925 char *kwnames[] = {
38926 (char *) "self",(char *) "ratio", NULL
38927 };
38928
38929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38931 if (SWIG_arg_fail(1)) SWIG_fail;
38932 {
38933 arg2 = (float)(SWIG_As_float(obj1));
38934 if (SWIG_arg_fail(2)) SWIG_fail;
38935 }
38936 {
38937 PyThreadState* __tstate = wxPyBeginAllowThreads();
38938 (arg1)->SetRatio(arg2);
38939
38940 wxPyEndAllowThreads(__tstate);
38941 if (PyErr_Occurred()) SWIG_fail;
38942 }
38943 Py_INCREF(Py_None); resultobj = Py_None;
38944 return resultobj;
38945 fail:
38946 return NULL;
38947 }
38948
38949
38950 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38951 PyObject *resultobj;
38952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38953 float result;
38954 PyObject * obj0 = 0 ;
38955 char *kwnames[] = {
38956 (char *) "self", NULL
38957 };
38958
38959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38961 if (SWIG_arg_fail(1)) SWIG_fail;
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 result = (float)(arg1)->GetRatio();
38965
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 {
38970 resultobj = SWIG_From_float((float)(result));
38971 }
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38979 PyObject *resultobj;
38980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38981 wxRect result;
38982 PyObject * obj0 = 0 ;
38983 char *kwnames[] = {
38984 (char *) "self", NULL
38985 };
38986
38987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38989 if (SWIG_arg_fail(1)) SWIG_fail;
38990 {
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (arg1)->GetRect();
38993
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 wxRect * resultptr;
38999 resultptr = new wxRect((wxRect &)(result));
39000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39001 }
39002 return resultobj;
39003 fail:
39004 return NULL;
39005 }
39006
39007
39008 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj;
39010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39011 bool result;
39012 PyObject * obj0 = 0 ;
39013 char *kwnames[] = {
39014 (char *) "self", NULL
39015 };
39016
39017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39019 if (SWIG_arg_fail(1)) SWIG_fail;
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 result = (bool)(arg1)->IsWindow();
39023
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 {
39028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39029 }
39030 return resultobj;
39031 fail:
39032 return NULL;
39033 }
39034
39035
39036 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39037 PyObject *resultobj;
39038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39039 bool result;
39040 PyObject * obj0 = 0 ;
39041 char *kwnames[] = {
39042 (char *) "self", NULL
39043 };
39044
39045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39047 if (SWIG_arg_fail(1)) SWIG_fail;
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (bool)(arg1)->IsSizer();
39051
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 {
39056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39057 }
39058 return resultobj;
39059 fail:
39060 return NULL;
39061 }
39062
39063
39064 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj;
39066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39067 bool result;
39068 PyObject * obj0 = 0 ;
39069 char *kwnames[] = {
39070 (char *) "self", NULL
39071 };
39072
39073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39075 if (SWIG_arg_fail(1)) SWIG_fail;
39076 {
39077 PyThreadState* __tstate = wxPyBeginAllowThreads();
39078 result = (bool)(arg1)->IsSpacer();
39079
39080 wxPyEndAllowThreads(__tstate);
39081 if (PyErr_Occurred()) SWIG_fail;
39082 }
39083 {
39084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39085 }
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39093 PyObject *resultobj;
39094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39095 int arg2 ;
39096 PyObject * obj0 = 0 ;
39097 PyObject * obj1 = 0 ;
39098 char *kwnames[] = {
39099 (char *) "self",(char *) "proportion", NULL
39100 };
39101
39102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39104 if (SWIG_arg_fail(1)) SWIG_fail;
39105 {
39106 arg2 = (int)(SWIG_As_int(obj1));
39107 if (SWIG_arg_fail(2)) SWIG_fail;
39108 }
39109 {
39110 PyThreadState* __tstate = wxPyBeginAllowThreads();
39111 (arg1)->SetProportion(arg2);
39112
39113 wxPyEndAllowThreads(__tstate);
39114 if (PyErr_Occurred()) SWIG_fail;
39115 }
39116 Py_INCREF(Py_None); resultobj = Py_None;
39117 return resultobj;
39118 fail:
39119 return NULL;
39120 }
39121
39122
39123 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39124 PyObject *resultobj;
39125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39126 int result;
39127 PyObject * obj0 = 0 ;
39128 char *kwnames[] = {
39129 (char *) "self", NULL
39130 };
39131
39132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39134 if (SWIG_arg_fail(1)) SWIG_fail;
39135 {
39136 PyThreadState* __tstate = wxPyBeginAllowThreads();
39137 result = (int)(arg1)->GetProportion();
39138
39139 wxPyEndAllowThreads(__tstate);
39140 if (PyErr_Occurred()) SWIG_fail;
39141 }
39142 {
39143 resultobj = SWIG_From_int((int)(result));
39144 }
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj;
39153 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39154 int arg2 ;
39155 PyObject * obj0 = 0 ;
39156 PyObject * obj1 = 0 ;
39157 char *kwnames[] = {
39158 (char *) "self",(char *) "flag", NULL
39159 };
39160
39161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39163 if (SWIG_arg_fail(1)) SWIG_fail;
39164 {
39165 arg2 = (int)(SWIG_As_int(obj1));
39166 if (SWIG_arg_fail(2)) SWIG_fail;
39167 }
39168 {
39169 PyThreadState* __tstate = wxPyBeginAllowThreads();
39170 (arg1)->SetFlag(arg2);
39171
39172 wxPyEndAllowThreads(__tstate);
39173 if (PyErr_Occurred()) SWIG_fail;
39174 }
39175 Py_INCREF(Py_None); resultobj = Py_None;
39176 return resultobj;
39177 fail:
39178 return NULL;
39179 }
39180
39181
39182 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39183 PyObject *resultobj;
39184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39185 int result;
39186 PyObject * obj0 = 0 ;
39187 char *kwnames[] = {
39188 (char *) "self", NULL
39189 };
39190
39191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39193 if (SWIG_arg_fail(1)) SWIG_fail;
39194 {
39195 PyThreadState* __tstate = wxPyBeginAllowThreads();
39196 result = (int)(arg1)->GetFlag();
39197
39198 wxPyEndAllowThreads(__tstate);
39199 if (PyErr_Occurred()) SWIG_fail;
39200 }
39201 {
39202 resultobj = SWIG_From_int((int)(result));
39203 }
39204 return resultobj;
39205 fail:
39206 return NULL;
39207 }
39208
39209
39210 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39211 PyObject *resultobj;
39212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39213 int arg2 ;
39214 PyObject * obj0 = 0 ;
39215 PyObject * obj1 = 0 ;
39216 char *kwnames[] = {
39217 (char *) "self",(char *) "border", NULL
39218 };
39219
39220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39222 if (SWIG_arg_fail(1)) SWIG_fail;
39223 {
39224 arg2 = (int)(SWIG_As_int(obj1));
39225 if (SWIG_arg_fail(2)) SWIG_fail;
39226 }
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 (arg1)->SetBorder(arg2);
39230
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 Py_INCREF(Py_None); resultobj = Py_None;
39235 return resultobj;
39236 fail:
39237 return NULL;
39238 }
39239
39240
39241 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj;
39243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39244 int result;
39245 PyObject * obj0 = 0 ;
39246 char *kwnames[] = {
39247 (char *) "self", NULL
39248 };
39249
39250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39252 if (SWIG_arg_fail(1)) SWIG_fail;
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = (int)(arg1)->GetBorder();
39256
39257 wxPyEndAllowThreads(__tstate);
39258 if (PyErr_Occurred()) SWIG_fail;
39259 }
39260 {
39261 resultobj = SWIG_From_int((int)(result));
39262 }
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj;
39271 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39272 wxWindow *result;
39273 PyObject * obj0 = 0 ;
39274 char *kwnames[] = {
39275 (char *) "self", NULL
39276 };
39277
39278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39280 if (SWIG_arg_fail(1)) SWIG_fail;
39281 {
39282 PyThreadState* __tstate = wxPyBeginAllowThreads();
39283 result = (wxWindow *)(arg1)->GetWindow();
39284
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, 0);
39290 }
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj;
39299 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39300 wxWindow *arg2 = (wxWindow *) 0 ;
39301 PyObject * obj0 = 0 ;
39302 PyObject * obj1 = 0 ;
39303 char *kwnames[] = {
39304 (char *) "self",(char *) "window", NULL
39305 };
39306
39307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39309 if (SWIG_arg_fail(1)) SWIG_fail;
39310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39311 if (SWIG_arg_fail(2)) SWIG_fail;
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 (arg1)->SetWindow(arg2);
39315
39316 wxPyEndAllowThreads(__tstate);
39317 if (PyErr_Occurred()) SWIG_fail;
39318 }
39319 Py_INCREF(Py_None); resultobj = Py_None;
39320 return resultobj;
39321 fail:
39322 return NULL;
39323 }
39324
39325
39326 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39327 PyObject *resultobj;
39328 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39329 wxSizer *result;
39330 PyObject * obj0 = 0 ;
39331 char *kwnames[] = {
39332 (char *) "self", NULL
39333 };
39334
39335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39337 if (SWIG_arg_fail(1)) SWIG_fail;
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 result = (wxSizer *)(arg1)->GetSizer();
39341
39342 wxPyEndAllowThreads(__tstate);
39343 if (PyErr_Occurred()) SWIG_fail;
39344 }
39345 {
39346 resultobj = wxPyMake_wxSizer(result, 0);
39347 }
39348 return resultobj;
39349 fail:
39350 return NULL;
39351 }
39352
39353
39354 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39355 PyObject *resultobj;
39356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39357 wxSizer *arg2 = (wxSizer *) 0 ;
39358 PyObject * obj0 = 0 ;
39359 PyObject * obj1 = 0 ;
39360 char *kwnames[] = {
39361 (char *) "self",(char *) "sizer", NULL
39362 };
39363
39364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39366 if (SWIG_arg_fail(1)) SWIG_fail;
39367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39368 if (SWIG_arg_fail(2)) SWIG_fail;
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 (arg1)->SetSizer(arg2);
39372
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 Py_INCREF(Py_None); resultobj = Py_None;
39377 return resultobj;
39378 fail:
39379 return NULL;
39380 }
39381
39382
39383 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39384 PyObject *resultobj;
39385 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39386 wxSize *result;
39387 PyObject * obj0 = 0 ;
39388 char *kwnames[] = {
39389 (char *) "self", NULL
39390 };
39391
39392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39394 if (SWIG_arg_fail(1)) SWIG_fail;
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 {
39398 wxSize const &_result_ref = (arg1)->GetSpacer();
39399 result = (wxSize *) &_result_ref;
39400 }
39401
39402 wxPyEndAllowThreads(__tstate);
39403 if (PyErr_Occurred()) SWIG_fail;
39404 }
39405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39406 return resultobj;
39407 fail:
39408 return NULL;
39409 }
39410
39411
39412 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39413 PyObject *resultobj;
39414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39415 wxSize *arg2 = 0 ;
39416 wxSize temp2 ;
39417 PyObject * obj0 = 0 ;
39418 PyObject * obj1 = 0 ;
39419 char *kwnames[] = {
39420 (char *) "self",(char *) "size", NULL
39421 };
39422
39423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39425 if (SWIG_arg_fail(1)) SWIG_fail;
39426 {
39427 arg2 = &temp2;
39428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39429 }
39430 {
39431 PyThreadState* __tstate = wxPyBeginAllowThreads();
39432 (arg1)->SetSpacer((wxSize const &)*arg2);
39433
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 Py_INCREF(Py_None); resultobj = Py_None;
39438 return resultobj;
39439 fail:
39440 return NULL;
39441 }
39442
39443
39444 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39445 PyObject *resultobj;
39446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39447 bool arg2 ;
39448 PyObject * obj0 = 0 ;
39449 PyObject * obj1 = 0 ;
39450 char *kwnames[] = {
39451 (char *) "self",(char *) "show", NULL
39452 };
39453
39454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39456 if (SWIG_arg_fail(1)) SWIG_fail;
39457 {
39458 arg2 = (bool)(SWIG_As_bool(obj1));
39459 if (SWIG_arg_fail(2)) SWIG_fail;
39460 }
39461 {
39462 PyThreadState* __tstate = wxPyBeginAllowThreads();
39463 (arg1)->Show(arg2);
39464
39465 wxPyEndAllowThreads(__tstate);
39466 if (PyErr_Occurred()) SWIG_fail;
39467 }
39468 Py_INCREF(Py_None); resultobj = Py_None;
39469 return resultobj;
39470 fail:
39471 return NULL;
39472 }
39473
39474
39475 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39476 PyObject *resultobj;
39477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39478 bool result;
39479 PyObject * obj0 = 0 ;
39480 char *kwnames[] = {
39481 (char *) "self", NULL
39482 };
39483
39484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39486 if (SWIG_arg_fail(1)) SWIG_fail;
39487 {
39488 PyThreadState* __tstate = wxPyBeginAllowThreads();
39489 result = (bool)(arg1)->IsShown();
39490
39491 wxPyEndAllowThreads(__tstate);
39492 if (PyErr_Occurred()) SWIG_fail;
39493 }
39494 {
39495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39496 }
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39504 PyObject *resultobj;
39505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39506 wxPoint result;
39507 PyObject * obj0 = 0 ;
39508 char *kwnames[] = {
39509 (char *) "self", NULL
39510 };
39511
39512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39514 if (SWIG_arg_fail(1)) SWIG_fail;
39515 {
39516 PyThreadState* __tstate = wxPyBeginAllowThreads();
39517 result = (arg1)->GetPosition();
39518
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 wxPoint * resultptr;
39524 resultptr = new wxPoint((wxPoint &)(result));
39525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39526 }
39527 return resultobj;
39528 fail:
39529 return NULL;
39530 }
39531
39532
39533 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39534 PyObject *resultobj;
39535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39536 PyObject *result;
39537 PyObject * obj0 = 0 ;
39538 char *kwnames[] = {
39539 (char *) "self", NULL
39540 };
39541
39542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39544 if (SWIG_arg_fail(1)) SWIG_fail;
39545 {
39546 PyThreadState* __tstate = wxPyBeginAllowThreads();
39547 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39548
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 resultobj = result;
39553 return resultobj;
39554 fail:
39555 return NULL;
39556 }
39557
39558
39559 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39560 PyObject *obj;
39561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39562 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39563 Py_INCREF(obj);
39564 return Py_BuildValue((char *)"");
39565 }
39566 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39567 PyObject *resultobj;
39568 wxSizer *arg1 = (wxSizer *) 0 ;
39569 PyObject *arg2 = (PyObject *) 0 ;
39570 PyObject * obj0 = 0 ;
39571 PyObject * obj1 = 0 ;
39572 char *kwnames[] = {
39573 (char *) "self",(char *) "_self", NULL
39574 };
39575
39576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39578 if (SWIG_arg_fail(1)) SWIG_fail;
39579 arg2 = obj1;
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 wxSizer__setOORInfo(arg1,arg2);
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 Py_INCREF(Py_None); resultobj = Py_None;
39588 return resultobj;
39589 fail:
39590 return NULL;
39591 }
39592
39593
39594 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj;
39596 wxSizer *arg1 = (wxSizer *) 0 ;
39597 PyObject *arg2 = (PyObject *) 0 ;
39598 int arg3 = (int) 0 ;
39599 int arg4 = (int) 0 ;
39600 int arg5 = (int) 0 ;
39601 PyObject *arg6 = (PyObject *) NULL ;
39602 wxSizerItem *result;
39603 PyObject * obj0 = 0 ;
39604 PyObject * obj1 = 0 ;
39605 PyObject * obj2 = 0 ;
39606 PyObject * obj3 = 0 ;
39607 PyObject * obj4 = 0 ;
39608 PyObject * obj5 = 0 ;
39609 char *kwnames[] = {
39610 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39611 };
39612
39613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39615 if (SWIG_arg_fail(1)) SWIG_fail;
39616 arg2 = obj1;
39617 if (obj2) {
39618 {
39619 arg3 = (int)(SWIG_As_int(obj2));
39620 if (SWIG_arg_fail(3)) SWIG_fail;
39621 }
39622 }
39623 if (obj3) {
39624 {
39625 arg4 = (int)(SWIG_As_int(obj3));
39626 if (SWIG_arg_fail(4)) SWIG_fail;
39627 }
39628 }
39629 if (obj4) {
39630 {
39631 arg5 = (int)(SWIG_As_int(obj4));
39632 if (SWIG_arg_fail(5)) SWIG_fail;
39633 }
39634 }
39635 if (obj5) {
39636 arg6 = obj5;
39637 }
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39641
39642 wxPyEndAllowThreads(__tstate);
39643 if (PyErr_Occurred()) SWIG_fail;
39644 }
39645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39646 return resultobj;
39647 fail:
39648 return NULL;
39649 }
39650
39651
39652 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39653 PyObject *resultobj;
39654 wxSizer *arg1 = (wxSizer *) 0 ;
39655 int arg2 ;
39656 PyObject *arg3 = (PyObject *) 0 ;
39657 int arg4 = (int) 0 ;
39658 int arg5 = (int) 0 ;
39659 int arg6 = (int) 0 ;
39660 PyObject *arg7 = (PyObject *) NULL ;
39661 wxSizerItem *result;
39662 PyObject * obj0 = 0 ;
39663 PyObject * obj1 = 0 ;
39664 PyObject * obj2 = 0 ;
39665 PyObject * obj3 = 0 ;
39666 PyObject * obj4 = 0 ;
39667 PyObject * obj5 = 0 ;
39668 PyObject * obj6 = 0 ;
39669 char *kwnames[] = {
39670 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39671 };
39672
39673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39675 if (SWIG_arg_fail(1)) SWIG_fail;
39676 {
39677 arg2 = (int)(SWIG_As_int(obj1));
39678 if (SWIG_arg_fail(2)) SWIG_fail;
39679 }
39680 arg3 = obj2;
39681 if (obj3) {
39682 {
39683 arg4 = (int)(SWIG_As_int(obj3));
39684 if (SWIG_arg_fail(4)) SWIG_fail;
39685 }
39686 }
39687 if (obj4) {
39688 {
39689 arg5 = (int)(SWIG_As_int(obj4));
39690 if (SWIG_arg_fail(5)) SWIG_fail;
39691 }
39692 }
39693 if (obj5) {
39694 {
39695 arg6 = (int)(SWIG_As_int(obj5));
39696 if (SWIG_arg_fail(6)) SWIG_fail;
39697 }
39698 }
39699 if (obj6) {
39700 arg7 = obj6;
39701 }
39702 {
39703 PyThreadState* __tstate = wxPyBeginAllowThreads();
39704 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39705
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39710 return resultobj;
39711 fail:
39712 return NULL;
39713 }
39714
39715
39716 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39717 PyObject *resultobj;
39718 wxSizer *arg1 = (wxSizer *) 0 ;
39719 PyObject *arg2 = (PyObject *) 0 ;
39720 int arg3 = (int) 0 ;
39721 int arg4 = (int) 0 ;
39722 int arg5 = (int) 0 ;
39723 PyObject *arg6 = (PyObject *) NULL ;
39724 wxSizerItem *result;
39725 PyObject * obj0 = 0 ;
39726 PyObject * obj1 = 0 ;
39727 PyObject * obj2 = 0 ;
39728 PyObject * obj3 = 0 ;
39729 PyObject * obj4 = 0 ;
39730 PyObject * obj5 = 0 ;
39731 char *kwnames[] = {
39732 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39733 };
39734
39735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39737 if (SWIG_arg_fail(1)) SWIG_fail;
39738 arg2 = obj1;
39739 if (obj2) {
39740 {
39741 arg3 = (int)(SWIG_As_int(obj2));
39742 if (SWIG_arg_fail(3)) SWIG_fail;
39743 }
39744 }
39745 if (obj3) {
39746 {
39747 arg4 = (int)(SWIG_As_int(obj3));
39748 if (SWIG_arg_fail(4)) SWIG_fail;
39749 }
39750 }
39751 if (obj4) {
39752 {
39753 arg5 = (int)(SWIG_As_int(obj4));
39754 if (SWIG_arg_fail(5)) SWIG_fail;
39755 }
39756 }
39757 if (obj5) {
39758 arg6 = obj5;
39759 }
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39763
39764 wxPyEndAllowThreads(__tstate);
39765 if (PyErr_Occurred()) SWIG_fail;
39766 }
39767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39768 return resultobj;
39769 fail:
39770 return NULL;
39771 }
39772
39773
39774 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39775 PyObject *resultobj;
39776 wxSizer *arg1 = (wxSizer *) 0 ;
39777 PyObject *arg2 = (PyObject *) 0 ;
39778 bool result;
39779 PyObject * obj0 = 0 ;
39780 PyObject * obj1 = 0 ;
39781 char *kwnames[] = {
39782 (char *) "self",(char *) "item", NULL
39783 };
39784
39785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39787 if (SWIG_arg_fail(1)) SWIG_fail;
39788 arg2 = obj1;
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 result = (bool)wxSizer_Remove(arg1,arg2);
39792
39793 wxPyEndAllowThreads(__tstate);
39794 if (PyErr_Occurred()) SWIG_fail;
39795 }
39796 {
39797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39798 }
39799 return resultobj;
39800 fail:
39801 return NULL;
39802 }
39803
39804
39805 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj;
39807 wxSizer *arg1 = (wxSizer *) 0 ;
39808 PyObject *arg2 = (PyObject *) 0 ;
39809 bool result;
39810 PyObject * obj0 = 0 ;
39811 PyObject * obj1 = 0 ;
39812 char *kwnames[] = {
39813 (char *) "self",(char *) "item", NULL
39814 };
39815
39816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39818 if (SWIG_arg_fail(1)) SWIG_fail;
39819 arg2 = obj1;
39820 {
39821 PyThreadState* __tstate = wxPyBeginAllowThreads();
39822 result = (bool)wxSizer_Detach(arg1,arg2);
39823
39824 wxPyEndAllowThreads(__tstate);
39825 if (PyErr_Occurred()) SWIG_fail;
39826 }
39827 {
39828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39829 }
39830 return resultobj;
39831 fail:
39832 return NULL;
39833 }
39834
39835
39836 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39837 PyObject *resultobj;
39838 wxSizer *arg1 = (wxSizer *) 0 ;
39839 PyObject *arg2 = (PyObject *) 0 ;
39840 wxSizerItem *result;
39841 PyObject * obj0 = 0 ;
39842 PyObject * obj1 = 0 ;
39843 char *kwnames[] = {
39844 (char *) "self",(char *) "item", NULL
39845 };
39846
39847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39849 if (SWIG_arg_fail(1)) SWIG_fail;
39850 arg2 = obj1;
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39859 return resultobj;
39860 fail:
39861 return NULL;
39862 }
39863
39864
39865 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj;
39867 wxSizer *arg1 = (wxSizer *) 0 ;
39868 PyObject *arg2 = (PyObject *) 0 ;
39869 wxSize *arg3 = 0 ;
39870 wxSize temp3 ;
39871 PyObject * obj0 = 0 ;
39872 PyObject * obj1 = 0 ;
39873 PyObject * obj2 = 0 ;
39874 char *kwnames[] = {
39875 (char *) "self",(char *) "item",(char *) "size", NULL
39876 };
39877
39878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39880 if (SWIG_arg_fail(1)) SWIG_fail;
39881 arg2 = obj1;
39882 {
39883 arg3 = &temp3;
39884 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39885 }
39886 {
39887 PyThreadState* __tstate = wxPyBeginAllowThreads();
39888 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39889
39890 wxPyEndAllowThreads(__tstate);
39891 if (PyErr_Occurred()) SWIG_fail;
39892 }
39893 Py_INCREF(Py_None); resultobj = Py_None;
39894 return resultobj;
39895 fail:
39896 return NULL;
39897 }
39898
39899
39900 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39901 PyObject *resultobj;
39902 wxSizer *arg1 = (wxSizer *) 0 ;
39903 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39904 wxSizerItem *result;
39905 PyObject * obj0 = 0 ;
39906 PyObject * obj1 = 0 ;
39907 char *kwnames[] = {
39908 (char *) "self",(char *) "item", NULL
39909 };
39910
39911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39913 if (SWIG_arg_fail(1)) SWIG_fail;
39914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39915 if (SWIG_arg_fail(2)) SWIG_fail;
39916 {
39917 PyThreadState* __tstate = wxPyBeginAllowThreads();
39918 result = (wxSizerItem *)(arg1)->Add(arg2);
39919
39920 wxPyEndAllowThreads(__tstate);
39921 if (PyErr_Occurred()) SWIG_fail;
39922 }
39923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39924 return resultobj;
39925 fail:
39926 return NULL;
39927 }
39928
39929
39930 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39931 PyObject *resultobj;
39932 wxSizer *arg1 = (wxSizer *) 0 ;
39933 size_t arg2 ;
39934 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39935 wxSizerItem *result;
39936 PyObject * obj0 = 0 ;
39937 PyObject * obj1 = 0 ;
39938 PyObject * obj2 = 0 ;
39939 char *kwnames[] = {
39940 (char *) "self",(char *) "index",(char *) "item", NULL
39941 };
39942
39943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39945 if (SWIG_arg_fail(1)) SWIG_fail;
39946 {
39947 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39948 if (SWIG_arg_fail(2)) SWIG_fail;
39949 }
39950 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39951 if (SWIG_arg_fail(3)) SWIG_fail;
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj;
39968 wxSizer *arg1 = (wxSizer *) 0 ;
39969 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39970 wxSizerItem *result;
39971 PyObject * obj0 = 0 ;
39972 PyObject * obj1 = 0 ;
39973 char *kwnames[] = {
39974 (char *) "self",(char *) "item", NULL
39975 };
39976
39977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(1)) SWIG_fail;
39980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39981 if (SWIG_arg_fail(2)) SWIG_fail;
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39985
39986 wxPyEndAllowThreads(__tstate);
39987 if (PyErr_Occurred()) SWIG_fail;
39988 }
39989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39997 PyObject *resultobj;
39998 wxSizer *arg1 = (wxSizer *) 0 ;
39999 int arg2 ;
40000 int arg3 ;
40001 int arg4 ;
40002 int arg5 ;
40003 PyObject * obj0 = 0 ;
40004 PyObject * obj1 = 0 ;
40005 PyObject * obj2 = 0 ;
40006 PyObject * obj3 = 0 ;
40007 PyObject * obj4 = 0 ;
40008 char *kwnames[] = {
40009 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40010 };
40011
40012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40014 if (SWIG_arg_fail(1)) SWIG_fail;
40015 {
40016 arg2 = (int)(SWIG_As_int(obj1));
40017 if (SWIG_arg_fail(2)) SWIG_fail;
40018 }
40019 {
40020 arg3 = (int)(SWIG_As_int(obj2));
40021 if (SWIG_arg_fail(3)) SWIG_fail;
40022 }
40023 {
40024 arg4 = (int)(SWIG_As_int(obj3));
40025 if (SWIG_arg_fail(4)) SWIG_fail;
40026 }
40027 {
40028 arg5 = (int)(SWIG_As_int(obj4));
40029 if (SWIG_arg_fail(5)) SWIG_fail;
40030 }
40031 {
40032 PyThreadState* __tstate = wxPyBeginAllowThreads();
40033 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40034
40035 wxPyEndAllowThreads(__tstate);
40036 if (PyErr_Occurred()) SWIG_fail;
40037 }
40038 Py_INCREF(Py_None); resultobj = Py_None;
40039 return resultobj;
40040 fail:
40041 return NULL;
40042 }
40043
40044
40045 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40046 PyObject *resultobj;
40047 wxSizer *arg1 = (wxSizer *) 0 ;
40048 wxSize *arg2 = 0 ;
40049 wxSize temp2 ;
40050 PyObject * obj0 = 0 ;
40051 PyObject * obj1 = 0 ;
40052 char *kwnames[] = {
40053 (char *) "self",(char *) "size", NULL
40054 };
40055
40056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40058 if (SWIG_arg_fail(1)) SWIG_fail;
40059 {
40060 arg2 = &temp2;
40061 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40062 }
40063 {
40064 PyThreadState* __tstate = wxPyBeginAllowThreads();
40065 (arg1)->SetMinSize((wxSize const &)*arg2);
40066
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 Py_INCREF(Py_None); resultobj = Py_None;
40071 return resultobj;
40072 fail:
40073 return NULL;
40074 }
40075
40076
40077 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40078 PyObject *resultobj;
40079 wxSizer *arg1 = (wxSizer *) 0 ;
40080 wxSize result;
40081 PyObject * obj0 = 0 ;
40082 char *kwnames[] = {
40083 (char *) "self", NULL
40084 };
40085
40086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40088 if (SWIG_arg_fail(1)) SWIG_fail;
40089 {
40090 PyThreadState* __tstate = wxPyBeginAllowThreads();
40091 result = (arg1)->GetSize();
40092
40093 wxPyEndAllowThreads(__tstate);
40094 if (PyErr_Occurred()) SWIG_fail;
40095 }
40096 {
40097 wxSize * resultptr;
40098 resultptr = new wxSize((wxSize &)(result));
40099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40100 }
40101 return resultobj;
40102 fail:
40103 return NULL;
40104 }
40105
40106
40107 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40108 PyObject *resultobj;
40109 wxSizer *arg1 = (wxSizer *) 0 ;
40110 wxPoint result;
40111 PyObject * obj0 = 0 ;
40112 char *kwnames[] = {
40113 (char *) "self", NULL
40114 };
40115
40116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40118 if (SWIG_arg_fail(1)) SWIG_fail;
40119 {
40120 PyThreadState* __tstate = wxPyBeginAllowThreads();
40121 result = (arg1)->GetPosition();
40122
40123 wxPyEndAllowThreads(__tstate);
40124 if (PyErr_Occurred()) SWIG_fail;
40125 }
40126 {
40127 wxPoint * resultptr;
40128 resultptr = new wxPoint((wxPoint &)(result));
40129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40130 }
40131 return resultobj;
40132 fail:
40133 return NULL;
40134 }
40135
40136
40137 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40138 PyObject *resultobj;
40139 wxSizer *arg1 = (wxSizer *) 0 ;
40140 wxSize result;
40141 PyObject * obj0 = 0 ;
40142 char *kwnames[] = {
40143 (char *) "self", NULL
40144 };
40145
40146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40148 if (SWIG_arg_fail(1)) SWIG_fail;
40149 {
40150 PyThreadState* __tstate = wxPyBeginAllowThreads();
40151 result = (arg1)->GetMinSize();
40152
40153 wxPyEndAllowThreads(__tstate);
40154 if (PyErr_Occurred()) SWIG_fail;
40155 }
40156 {
40157 wxSize * resultptr;
40158 resultptr = new wxSize((wxSize &)(result));
40159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40160 }
40161 return resultobj;
40162 fail:
40163 return NULL;
40164 }
40165
40166
40167 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40168 PyObject *resultobj;
40169 wxSizer *arg1 = (wxSizer *) 0 ;
40170 PyObject * obj0 = 0 ;
40171 char *kwnames[] = {
40172 (char *) "self", NULL
40173 };
40174
40175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40177 if (SWIG_arg_fail(1)) SWIG_fail;
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 (arg1)->RecalcSizes();
40181
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 Py_INCREF(Py_None); resultobj = Py_None;
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40193 PyObject *resultobj;
40194 wxSizer *arg1 = (wxSizer *) 0 ;
40195 wxSize result;
40196 PyObject * obj0 = 0 ;
40197 char *kwnames[] = {
40198 (char *) "self", NULL
40199 };
40200
40201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40203 if (SWIG_arg_fail(1)) SWIG_fail;
40204 {
40205 PyThreadState* __tstate = wxPyBeginAllowThreads();
40206 result = (arg1)->CalcMin();
40207
40208 wxPyEndAllowThreads(__tstate);
40209 if (PyErr_Occurred()) SWIG_fail;
40210 }
40211 {
40212 wxSize * resultptr;
40213 resultptr = new wxSize((wxSize &)(result));
40214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40215 }
40216 return resultobj;
40217 fail:
40218 return NULL;
40219 }
40220
40221
40222 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40223 PyObject *resultobj;
40224 wxSizer *arg1 = (wxSizer *) 0 ;
40225 PyObject * obj0 = 0 ;
40226 char *kwnames[] = {
40227 (char *) "self", NULL
40228 };
40229
40230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40232 if (SWIG_arg_fail(1)) SWIG_fail;
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 (arg1)->Layout();
40236
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 Py_INCREF(Py_None); resultobj = Py_None;
40241 return resultobj;
40242 fail:
40243 return NULL;
40244 }
40245
40246
40247 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj;
40249 wxSizer *arg1 = (wxSizer *) 0 ;
40250 wxWindow *arg2 = (wxWindow *) 0 ;
40251 wxSize result;
40252 PyObject * obj0 = 0 ;
40253 PyObject * obj1 = 0 ;
40254 char *kwnames[] = {
40255 (char *) "self",(char *) "window", NULL
40256 };
40257
40258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(1)) SWIG_fail;
40261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40262 if (SWIG_arg_fail(2)) SWIG_fail;
40263 {
40264 PyThreadState* __tstate = wxPyBeginAllowThreads();
40265 result = (arg1)->Fit(arg2);
40266
40267 wxPyEndAllowThreads(__tstate);
40268 if (PyErr_Occurred()) SWIG_fail;
40269 }
40270 {
40271 wxSize * resultptr;
40272 resultptr = new wxSize((wxSize &)(result));
40273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40274 }
40275 return resultobj;
40276 fail:
40277 return NULL;
40278 }
40279
40280
40281 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40282 PyObject *resultobj;
40283 wxSizer *arg1 = (wxSizer *) 0 ;
40284 wxWindow *arg2 = (wxWindow *) 0 ;
40285 PyObject * obj0 = 0 ;
40286 PyObject * obj1 = 0 ;
40287 char *kwnames[] = {
40288 (char *) "self",(char *) "window", NULL
40289 };
40290
40291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40293 if (SWIG_arg_fail(1)) SWIG_fail;
40294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40295 if (SWIG_arg_fail(2)) SWIG_fail;
40296 {
40297 PyThreadState* __tstate = wxPyBeginAllowThreads();
40298 (arg1)->FitInside(arg2);
40299
40300 wxPyEndAllowThreads(__tstate);
40301 if (PyErr_Occurred()) SWIG_fail;
40302 }
40303 Py_INCREF(Py_None); resultobj = Py_None;
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj;
40312 wxSizer *arg1 = (wxSizer *) 0 ;
40313 wxWindow *arg2 = (wxWindow *) 0 ;
40314 PyObject * obj0 = 0 ;
40315 PyObject * obj1 = 0 ;
40316 char *kwnames[] = {
40317 (char *) "self",(char *) "window", NULL
40318 };
40319
40320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40322 if (SWIG_arg_fail(1)) SWIG_fail;
40323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40324 if (SWIG_arg_fail(2)) SWIG_fail;
40325 {
40326 PyThreadState* __tstate = wxPyBeginAllowThreads();
40327 (arg1)->SetSizeHints(arg2);
40328
40329 wxPyEndAllowThreads(__tstate);
40330 if (PyErr_Occurred()) SWIG_fail;
40331 }
40332 Py_INCREF(Py_None); resultobj = Py_None;
40333 return resultobj;
40334 fail:
40335 return NULL;
40336 }
40337
40338
40339 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj;
40341 wxSizer *arg1 = (wxSizer *) 0 ;
40342 wxWindow *arg2 = (wxWindow *) 0 ;
40343 PyObject * obj0 = 0 ;
40344 PyObject * obj1 = 0 ;
40345 char *kwnames[] = {
40346 (char *) "self",(char *) "window", NULL
40347 };
40348
40349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40351 if (SWIG_arg_fail(1)) SWIG_fail;
40352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40353 if (SWIG_arg_fail(2)) SWIG_fail;
40354 {
40355 PyThreadState* __tstate = wxPyBeginAllowThreads();
40356 (arg1)->SetVirtualSizeHints(arg2);
40357
40358 wxPyEndAllowThreads(__tstate);
40359 if (PyErr_Occurred()) SWIG_fail;
40360 }
40361 Py_INCREF(Py_None); resultobj = Py_None;
40362 return resultobj;
40363 fail:
40364 return NULL;
40365 }
40366
40367
40368 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40369 PyObject *resultobj;
40370 wxSizer *arg1 = (wxSizer *) 0 ;
40371 bool arg2 = (bool) false ;
40372 PyObject * obj0 = 0 ;
40373 PyObject * obj1 = 0 ;
40374 char *kwnames[] = {
40375 (char *) "self",(char *) "deleteWindows", NULL
40376 };
40377
40378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40380 if (SWIG_arg_fail(1)) SWIG_fail;
40381 if (obj1) {
40382 {
40383 arg2 = (bool)(SWIG_As_bool(obj1));
40384 if (SWIG_arg_fail(2)) SWIG_fail;
40385 }
40386 }
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 (arg1)->Clear(arg2);
40390
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 Py_INCREF(Py_None); resultobj = Py_None;
40395 return resultobj;
40396 fail:
40397 return NULL;
40398 }
40399
40400
40401 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40402 PyObject *resultobj;
40403 wxSizer *arg1 = (wxSizer *) 0 ;
40404 PyObject * obj0 = 0 ;
40405 char *kwnames[] = {
40406 (char *) "self", NULL
40407 };
40408
40409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40411 if (SWIG_arg_fail(1)) SWIG_fail;
40412 {
40413 PyThreadState* __tstate = wxPyBeginAllowThreads();
40414 (arg1)->DeleteWindows();
40415
40416 wxPyEndAllowThreads(__tstate);
40417 if (PyErr_Occurred()) SWIG_fail;
40418 }
40419 Py_INCREF(Py_None); resultobj = Py_None;
40420 return resultobj;
40421 fail:
40422 return NULL;
40423 }
40424
40425
40426 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj;
40428 wxSizer *arg1 = (wxSizer *) 0 ;
40429 PyObject *result;
40430 PyObject * obj0 = 0 ;
40431 char *kwnames[] = {
40432 (char *) "self", NULL
40433 };
40434
40435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40437 if (SWIG_arg_fail(1)) SWIG_fail;
40438 {
40439 PyThreadState* __tstate = wxPyBeginAllowThreads();
40440 result = (PyObject *)wxSizer_GetChildren(arg1);
40441
40442 wxPyEndAllowThreads(__tstate);
40443 if (PyErr_Occurred()) SWIG_fail;
40444 }
40445 resultobj = result;
40446 return resultobj;
40447 fail:
40448 return NULL;
40449 }
40450
40451
40452 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40453 PyObject *resultobj;
40454 wxSizer *arg1 = (wxSizer *) 0 ;
40455 PyObject *arg2 = (PyObject *) 0 ;
40456 bool arg3 = (bool) true ;
40457 bool arg4 = (bool) false ;
40458 bool result;
40459 PyObject * obj0 = 0 ;
40460 PyObject * obj1 = 0 ;
40461 PyObject * obj2 = 0 ;
40462 PyObject * obj3 = 0 ;
40463 char *kwnames[] = {
40464 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40465 };
40466
40467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40469 if (SWIG_arg_fail(1)) SWIG_fail;
40470 arg2 = obj1;
40471 if (obj2) {
40472 {
40473 arg3 = (bool)(SWIG_As_bool(obj2));
40474 if (SWIG_arg_fail(3)) SWIG_fail;
40475 }
40476 }
40477 if (obj3) {
40478 {
40479 arg4 = (bool)(SWIG_As_bool(obj3));
40480 if (SWIG_arg_fail(4)) SWIG_fail;
40481 }
40482 }
40483 {
40484 PyThreadState* __tstate = wxPyBeginAllowThreads();
40485 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40486
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 {
40491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40492 }
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj;
40501 wxSizer *arg1 = (wxSizer *) 0 ;
40502 PyObject *arg2 = (PyObject *) 0 ;
40503 bool result;
40504 PyObject * obj0 = 0 ;
40505 PyObject * obj1 = 0 ;
40506 char *kwnames[] = {
40507 (char *) "self",(char *) "item", NULL
40508 };
40509
40510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40512 if (SWIG_arg_fail(1)) SWIG_fail;
40513 arg2 = obj1;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = (bool)wxSizer_IsShown(arg1,arg2);
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40523 }
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj;
40532 wxSizer *arg1 = (wxSizer *) 0 ;
40533 bool arg2 ;
40534 PyObject * obj0 = 0 ;
40535 PyObject * obj1 = 0 ;
40536 char *kwnames[] = {
40537 (char *) "self",(char *) "show", NULL
40538 };
40539
40540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40542 if (SWIG_arg_fail(1)) SWIG_fail;
40543 {
40544 arg2 = (bool)(SWIG_As_bool(obj1));
40545 if (SWIG_arg_fail(2)) SWIG_fail;
40546 }
40547 {
40548 PyThreadState* __tstate = wxPyBeginAllowThreads();
40549 (arg1)->ShowItems(arg2);
40550
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 Py_INCREF(Py_None); resultobj = Py_None;
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40562 PyObject *obj;
40563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40564 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40565 Py_INCREF(obj);
40566 return Py_BuildValue((char *)"");
40567 }
40568 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40569 PyObject *resultobj;
40570 wxPySizer *result;
40571 char *kwnames[] = {
40572 NULL
40573 };
40574
40575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40576 {
40577 PyThreadState* __tstate = wxPyBeginAllowThreads();
40578 result = (wxPySizer *)new wxPySizer();
40579
40580 wxPyEndAllowThreads(__tstate);
40581 if (PyErr_Occurred()) SWIG_fail;
40582 }
40583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40584 return resultobj;
40585 fail:
40586 return NULL;
40587 }
40588
40589
40590 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40591 PyObject *resultobj;
40592 wxPySizer *arg1 = (wxPySizer *) 0 ;
40593 PyObject *arg2 = (PyObject *) 0 ;
40594 PyObject *arg3 = (PyObject *) 0 ;
40595 PyObject * obj0 = 0 ;
40596 PyObject * obj1 = 0 ;
40597 PyObject * obj2 = 0 ;
40598 char *kwnames[] = {
40599 (char *) "self",(char *) "self",(char *) "_class", NULL
40600 };
40601
40602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40604 if (SWIG_arg_fail(1)) SWIG_fail;
40605 arg2 = obj1;
40606 arg3 = obj2;
40607 {
40608 PyThreadState* __tstate = wxPyBeginAllowThreads();
40609 (arg1)->_setCallbackInfo(arg2,arg3);
40610
40611 wxPyEndAllowThreads(__tstate);
40612 if (PyErr_Occurred()) SWIG_fail;
40613 }
40614 Py_INCREF(Py_None); resultobj = Py_None;
40615 return resultobj;
40616 fail:
40617 return NULL;
40618 }
40619
40620
40621 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40622 PyObject *obj;
40623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40624 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40625 Py_INCREF(obj);
40626 return Py_BuildValue((char *)"");
40627 }
40628 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40629 PyObject *resultobj;
40630 int arg1 = (int) wxHORIZONTAL ;
40631 wxBoxSizer *result;
40632 PyObject * obj0 = 0 ;
40633 char *kwnames[] = {
40634 (char *) "orient", NULL
40635 };
40636
40637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40638 if (obj0) {
40639 {
40640 arg1 = (int)(SWIG_As_int(obj0));
40641 if (SWIG_arg_fail(1)) SWIG_fail;
40642 }
40643 }
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40647
40648 wxPyEndAllowThreads(__tstate);
40649 if (PyErr_Occurred()) SWIG_fail;
40650 }
40651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40652 return resultobj;
40653 fail:
40654 return NULL;
40655 }
40656
40657
40658 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40659 PyObject *resultobj;
40660 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40661 int result;
40662 PyObject * obj0 = 0 ;
40663 char *kwnames[] = {
40664 (char *) "self", NULL
40665 };
40666
40667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40669 if (SWIG_arg_fail(1)) SWIG_fail;
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 result = (int)(arg1)->GetOrientation();
40673
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 {
40678 resultobj = SWIG_From_int((int)(result));
40679 }
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40687 PyObject *resultobj;
40688 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40689 int arg2 ;
40690 PyObject * obj0 = 0 ;
40691 PyObject * obj1 = 0 ;
40692 char *kwnames[] = {
40693 (char *) "self",(char *) "orient", NULL
40694 };
40695
40696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40698 if (SWIG_arg_fail(1)) SWIG_fail;
40699 {
40700 arg2 = (int)(SWIG_As_int(obj1));
40701 if (SWIG_arg_fail(2)) SWIG_fail;
40702 }
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 (arg1)->SetOrientation(arg2);
40706
40707 wxPyEndAllowThreads(__tstate);
40708 if (PyErr_Occurred()) SWIG_fail;
40709 }
40710 Py_INCREF(Py_None); resultobj = Py_None;
40711 return resultobj;
40712 fail:
40713 return NULL;
40714 }
40715
40716
40717 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40718 PyObject *obj;
40719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40720 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40721 Py_INCREF(obj);
40722 return Py_BuildValue((char *)"");
40723 }
40724 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40725 PyObject *resultobj;
40726 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40727 int arg2 = (int) wxHORIZONTAL ;
40728 wxStaticBoxSizer *result;
40729 PyObject * obj0 = 0 ;
40730 PyObject * obj1 = 0 ;
40731 char *kwnames[] = {
40732 (char *) "box",(char *) "orient", NULL
40733 };
40734
40735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40737 if (SWIG_arg_fail(1)) SWIG_fail;
40738 if (obj1) {
40739 {
40740 arg2 = (int)(SWIG_As_int(obj1));
40741 if (SWIG_arg_fail(2)) SWIG_fail;
40742 }
40743 }
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40747
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj;
40760 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40761 wxStaticBox *result;
40762 PyObject * obj0 = 0 ;
40763 char *kwnames[] = {
40764 (char *) "self", NULL
40765 };
40766
40767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40769 if (SWIG_arg_fail(1)) SWIG_fail;
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = (wxStaticBox *)(arg1)->GetStaticBox();
40773
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 {
40778 resultobj = wxPyMake_wxObject(result, 0);
40779 }
40780 return resultobj;
40781 fail:
40782 return NULL;
40783 }
40784
40785
40786 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40787 PyObject *obj;
40788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40789 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40790 Py_INCREF(obj);
40791 return Py_BuildValue((char *)"");
40792 }
40793 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40794 PyObject *resultobj;
40795 int arg1 = (int) 1 ;
40796 int arg2 = (int) 0 ;
40797 int arg3 = (int) 0 ;
40798 int arg4 = (int) 0 ;
40799 wxGridSizer *result;
40800 PyObject * obj0 = 0 ;
40801 PyObject * obj1 = 0 ;
40802 PyObject * obj2 = 0 ;
40803 PyObject * obj3 = 0 ;
40804 char *kwnames[] = {
40805 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40806 };
40807
40808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40809 if (obj0) {
40810 {
40811 arg1 = (int)(SWIG_As_int(obj0));
40812 if (SWIG_arg_fail(1)) SWIG_fail;
40813 }
40814 }
40815 if (obj1) {
40816 {
40817 arg2 = (int)(SWIG_As_int(obj1));
40818 if (SWIG_arg_fail(2)) SWIG_fail;
40819 }
40820 }
40821 if (obj2) {
40822 {
40823 arg3 = (int)(SWIG_As_int(obj2));
40824 if (SWIG_arg_fail(3)) SWIG_fail;
40825 }
40826 }
40827 if (obj3) {
40828 {
40829 arg4 = (int)(SWIG_As_int(obj3));
40830 if (SWIG_arg_fail(4)) SWIG_fail;
40831 }
40832 }
40833 {
40834 PyThreadState* __tstate = wxPyBeginAllowThreads();
40835 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40836
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40841 return resultobj;
40842 fail:
40843 return NULL;
40844 }
40845
40846
40847 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj;
40849 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40850 int arg2 ;
40851 PyObject * obj0 = 0 ;
40852 PyObject * obj1 = 0 ;
40853 char *kwnames[] = {
40854 (char *) "self",(char *) "cols", NULL
40855 };
40856
40857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40859 if (SWIG_arg_fail(1)) SWIG_fail;
40860 {
40861 arg2 = (int)(SWIG_As_int(obj1));
40862 if (SWIG_arg_fail(2)) SWIG_fail;
40863 }
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 (arg1)->SetCols(arg2);
40867
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 Py_INCREF(Py_None); resultobj = Py_None;
40872 return resultobj;
40873 fail:
40874 return NULL;
40875 }
40876
40877
40878 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40879 PyObject *resultobj;
40880 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40881 int arg2 ;
40882 PyObject * obj0 = 0 ;
40883 PyObject * obj1 = 0 ;
40884 char *kwnames[] = {
40885 (char *) "self",(char *) "rows", NULL
40886 };
40887
40888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40890 if (SWIG_arg_fail(1)) SWIG_fail;
40891 {
40892 arg2 = (int)(SWIG_As_int(obj1));
40893 if (SWIG_arg_fail(2)) SWIG_fail;
40894 }
40895 {
40896 PyThreadState* __tstate = wxPyBeginAllowThreads();
40897 (arg1)->SetRows(arg2);
40898
40899 wxPyEndAllowThreads(__tstate);
40900 if (PyErr_Occurred()) SWIG_fail;
40901 }
40902 Py_INCREF(Py_None); resultobj = Py_None;
40903 return resultobj;
40904 fail:
40905 return NULL;
40906 }
40907
40908
40909 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40910 PyObject *resultobj;
40911 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40912 int arg2 ;
40913 PyObject * obj0 = 0 ;
40914 PyObject * obj1 = 0 ;
40915 char *kwnames[] = {
40916 (char *) "self",(char *) "gap", NULL
40917 };
40918
40919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40921 if (SWIG_arg_fail(1)) SWIG_fail;
40922 {
40923 arg2 = (int)(SWIG_As_int(obj1));
40924 if (SWIG_arg_fail(2)) SWIG_fail;
40925 }
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 (arg1)->SetVGap(arg2);
40929
40930 wxPyEndAllowThreads(__tstate);
40931 if (PyErr_Occurred()) SWIG_fail;
40932 }
40933 Py_INCREF(Py_None); resultobj = Py_None;
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40941 PyObject *resultobj;
40942 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40943 int arg2 ;
40944 PyObject * obj0 = 0 ;
40945 PyObject * obj1 = 0 ;
40946 char *kwnames[] = {
40947 (char *) "self",(char *) "gap", NULL
40948 };
40949
40950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40952 if (SWIG_arg_fail(1)) SWIG_fail;
40953 {
40954 arg2 = (int)(SWIG_As_int(obj1));
40955 if (SWIG_arg_fail(2)) SWIG_fail;
40956 }
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 (arg1)->SetHGap(arg2);
40960
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 Py_INCREF(Py_None); resultobj = Py_None;
40965 return resultobj;
40966 fail:
40967 return NULL;
40968 }
40969
40970
40971 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj;
40973 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40974 int result;
40975 PyObject * obj0 = 0 ;
40976 char *kwnames[] = {
40977 (char *) "self", NULL
40978 };
40979
40980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40982 if (SWIG_arg_fail(1)) SWIG_fail;
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (int)(arg1)->GetCols();
40986
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 {
40991 resultobj = SWIG_From_int((int)(result));
40992 }
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj;
41001 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41002 int result;
41003 PyObject * obj0 = 0 ;
41004 char *kwnames[] = {
41005 (char *) "self", NULL
41006 };
41007
41008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41010 if (SWIG_arg_fail(1)) SWIG_fail;
41011 {
41012 PyThreadState* __tstate = wxPyBeginAllowThreads();
41013 result = (int)(arg1)->GetRows();
41014
41015 wxPyEndAllowThreads(__tstate);
41016 if (PyErr_Occurred()) SWIG_fail;
41017 }
41018 {
41019 resultobj = SWIG_From_int((int)(result));
41020 }
41021 return resultobj;
41022 fail:
41023 return NULL;
41024 }
41025
41026
41027 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41028 PyObject *resultobj;
41029 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41030 int result;
41031 PyObject * obj0 = 0 ;
41032 char *kwnames[] = {
41033 (char *) "self", NULL
41034 };
41035
41036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41038 if (SWIG_arg_fail(1)) SWIG_fail;
41039 {
41040 PyThreadState* __tstate = wxPyBeginAllowThreads();
41041 result = (int)(arg1)->GetVGap();
41042
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 {
41047 resultobj = SWIG_From_int((int)(result));
41048 }
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj;
41057 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41058 int result;
41059 PyObject * obj0 = 0 ;
41060 char *kwnames[] = {
41061 (char *) "self", NULL
41062 };
41063
41064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41066 if (SWIG_arg_fail(1)) SWIG_fail;
41067 {
41068 PyThreadState* __tstate = wxPyBeginAllowThreads();
41069 result = (int)(arg1)->GetHGap();
41070
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 {
41075 resultobj = SWIG_From_int((int)(result));
41076 }
41077 return resultobj;
41078 fail:
41079 return NULL;
41080 }
41081
41082
41083 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41084 PyObject *obj;
41085 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41086 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41087 Py_INCREF(obj);
41088 return Py_BuildValue((char *)"");
41089 }
41090 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41091 PyObject *resultobj;
41092 int arg1 = (int) 1 ;
41093 int arg2 = (int) 0 ;
41094 int arg3 = (int) 0 ;
41095 int arg4 = (int) 0 ;
41096 wxFlexGridSizer *result;
41097 PyObject * obj0 = 0 ;
41098 PyObject * obj1 = 0 ;
41099 PyObject * obj2 = 0 ;
41100 PyObject * obj3 = 0 ;
41101 char *kwnames[] = {
41102 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41103 };
41104
41105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41106 if (obj0) {
41107 {
41108 arg1 = (int)(SWIG_As_int(obj0));
41109 if (SWIG_arg_fail(1)) SWIG_fail;
41110 }
41111 }
41112 if (obj1) {
41113 {
41114 arg2 = (int)(SWIG_As_int(obj1));
41115 if (SWIG_arg_fail(2)) SWIG_fail;
41116 }
41117 }
41118 if (obj2) {
41119 {
41120 arg3 = (int)(SWIG_As_int(obj2));
41121 if (SWIG_arg_fail(3)) SWIG_fail;
41122 }
41123 }
41124 if (obj3) {
41125 {
41126 arg4 = (int)(SWIG_As_int(obj3));
41127 if (SWIG_arg_fail(4)) SWIG_fail;
41128 }
41129 }
41130 {
41131 PyThreadState* __tstate = wxPyBeginAllowThreads();
41132 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41133
41134 wxPyEndAllowThreads(__tstate);
41135 if (PyErr_Occurred()) SWIG_fail;
41136 }
41137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41138 return resultobj;
41139 fail:
41140 return NULL;
41141 }
41142
41143
41144 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj;
41146 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41147 size_t arg2 ;
41148 int arg3 = (int) 0 ;
41149 PyObject * obj0 = 0 ;
41150 PyObject * obj1 = 0 ;
41151 PyObject * obj2 = 0 ;
41152 char *kwnames[] = {
41153 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41154 };
41155
41156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41158 if (SWIG_arg_fail(1)) SWIG_fail;
41159 {
41160 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41161 if (SWIG_arg_fail(2)) SWIG_fail;
41162 }
41163 if (obj2) {
41164 {
41165 arg3 = (int)(SWIG_As_int(obj2));
41166 if (SWIG_arg_fail(3)) SWIG_fail;
41167 }
41168 }
41169 {
41170 PyThreadState* __tstate = wxPyBeginAllowThreads();
41171 (arg1)->AddGrowableRow(arg2,arg3);
41172
41173 wxPyEndAllowThreads(__tstate);
41174 if (PyErr_Occurred()) SWIG_fail;
41175 }
41176 Py_INCREF(Py_None); resultobj = Py_None;
41177 return resultobj;
41178 fail:
41179 return NULL;
41180 }
41181
41182
41183 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41184 PyObject *resultobj;
41185 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41186 size_t arg2 ;
41187 PyObject * obj0 = 0 ;
41188 PyObject * obj1 = 0 ;
41189 char *kwnames[] = {
41190 (char *) "self",(char *) "idx", NULL
41191 };
41192
41193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41195 if (SWIG_arg_fail(1)) SWIG_fail;
41196 {
41197 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41198 if (SWIG_arg_fail(2)) SWIG_fail;
41199 }
41200 {
41201 PyThreadState* __tstate = wxPyBeginAllowThreads();
41202 (arg1)->RemoveGrowableRow(arg2);
41203
41204 wxPyEndAllowThreads(__tstate);
41205 if (PyErr_Occurred()) SWIG_fail;
41206 }
41207 Py_INCREF(Py_None); resultobj = Py_None;
41208 return resultobj;
41209 fail:
41210 return NULL;
41211 }
41212
41213
41214 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41215 PyObject *resultobj;
41216 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41217 size_t arg2 ;
41218 int arg3 = (int) 0 ;
41219 PyObject * obj0 = 0 ;
41220 PyObject * obj1 = 0 ;
41221 PyObject * obj2 = 0 ;
41222 char *kwnames[] = {
41223 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41224 };
41225
41226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41228 if (SWIG_arg_fail(1)) SWIG_fail;
41229 {
41230 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41231 if (SWIG_arg_fail(2)) SWIG_fail;
41232 }
41233 if (obj2) {
41234 {
41235 arg3 = (int)(SWIG_As_int(obj2));
41236 if (SWIG_arg_fail(3)) SWIG_fail;
41237 }
41238 }
41239 {
41240 PyThreadState* __tstate = wxPyBeginAllowThreads();
41241 (arg1)->AddGrowableCol(arg2,arg3);
41242
41243 wxPyEndAllowThreads(__tstate);
41244 if (PyErr_Occurred()) SWIG_fail;
41245 }
41246 Py_INCREF(Py_None); resultobj = Py_None;
41247 return resultobj;
41248 fail:
41249 return NULL;
41250 }
41251
41252
41253 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41254 PyObject *resultobj;
41255 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41256 size_t arg2 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 char *kwnames[] = {
41260 (char *) "self",(char *) "idx", NULL
41261 };
41262
41263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41265 if (SWIG_arg_fail(1)) SWIG_fail;
41266 {
41267 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41268 if (SWIG_arg_fail(2)) SWIG_fail;
41269 }
41270 {
41271 PyThreadState* __tstate = wxPyBeginAllowThreads();
41272 (arg1)->RemoveGrowableCol(arg2);
41273
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 Py_INCREF(Py_None); resultobj = Py_None;
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj;
41286 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41287 int arg2 ;
41288 PyObject * obj0 = 0 ;
41289 PyObject * obj1 = 0 ;
41290 char *kwnames[] = {
41291 (char *) "self",(char *) "direction", NULL
41292 };
41293
41294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41296 if (SWIG_arg_fail(1)) SWIG_fail;
41297 {
41298 arg2 = (int)(SWIG_As_int(obj1));
41299 if (SWIG_arg_fail(2)) SWIG_fail;
41300 }
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 (arg1)->SetFlexibleDirection(arg2);
41304
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 Py_INCREF(Py_None); resultobj = Py_None;
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj;
41317 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41318 int result;
41319 PyObject * obj0 = 0 ;
41320 char *kwnames[] = {
41321 (char *) "self", NULL
41322 };
41323
41324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41326 if (SWIG_arg_fail(1)) SWIG_fail;
41327 {
41328 PyThreadState* __tstate = wxPyBeginAllowThreads();
41329 result = (int)(arg1)->GetFlexibleDirection();
41330
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 {
41335 resultobj = SWIG_From_int((int)(result));
41336 }
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj;
41345 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41346 wxFlexSizerGrowMode arg2 ;
41347 PyObject * obj0 = 0 ;
41348 PyObject * obj1 = 0 ;
41349 char *kwnames[] = {
41350 (char *) "self",(char *) "mode", NULL
41351 };
41352
41353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41355 if (SWIG_arg_fail(1)) SWIG_fail;
41356 {
41357 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41358 if (SWIG_arg_fail(2)) SWIG_fail;
41359 }
41360 {
41361 PyThreadState* __tstate = wxPyBeginAllowThreads();
41362 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41363
41364 wxPyEndAllowThreads(__tstate);
41365 if (PyErr_Occurred()) SWIG_fail;
41366 }
41367 Py_INCREF(Py_None); resultobj = Py_None;
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41375 PyObject *resultobj;
41376 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41377 wxFlexSizerGrowMode result;
41378 PyObject * obj0 = 0 ;
41379 char *kwnames[] = {
41380 (char *) "self", NULL
41381 };
41382
41383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41385 if (SWIG_arg_fail(1)) SWIG_fail;
41386 {
41387 PyThreadState* __tstate = wxPyBeginAllowThreads();
41388 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41389
41390 wxPyEndAllowThreads(__tstate);
41391 if (PyErr_Occurred()) SWIG_fail;
41392 }
41393 resultobj = SWIG_From_int((result));
41394 return resultobj;
41395 fail:
41396 return NULL;
41397 }
41398
41399
41400 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41401 PyObject *resultobj;
41402 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41403 wxArrayInt *result;
41404 PyObject * obj0 = 0 ;
41405 char *kwnames[] = {
41406 (char *) "self", NULL
41407 };
41408
41409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41411 if (SWIG_arg_fail(1)) SWIG_fail;
41412 {
41413 PyThreadState* __tstate = wxPyBeginAllowThreads();
41414 {
41415 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41416 result = (wxArrayInt *) &_result_ref;
41417 }
41418
41419 wxPyEndAllowThreads(__tstate);
41420 if (PyErr_Occurred()) SWIG_fail;
41421 }
41422 {
41423 resultobj = PyList_New(0);
41424 size_t idx;
41425 for (idx = 0; idx < result->GetCount(); idx += 1) {
41426 PyObject* val = PyInt_FromLong( result->Item(idx) );
41427 PyList_Append(resultobj, val);
41428 Py_DECREF(val);
41429 }
41430 }
41431 return resultobj;
41432 fail:
41433 return NULL;
41434 }
41435
41436
41437 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41438 PyObject *resultobj;
41439 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41440 wxArrayInt *result;
41441 PyObject * obj0 = 0 ;
41442 char *kwnames[] = {
41443 (char *) "self", NULL
41444 };
41445
41446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41448 if (SWIG_arg_fail(1)) SWIG_fail;
41449 {
41450 PyThreadState* __tstate = wxPyBeginAllowThreads();
41451 {
41452 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41453 result = (wxArrayInt *) &_result_ref;
41454 }
41455
41456 wxPyEndAllowThreads(__tstate);
41457 if (PyErr_Occurred()) SWIG_fail;
41458 }
41459 {
41460 resultobj = PyList_New(0);
41461 size_t idx;
41462 for (idx = 0; idx < result->GetCount(); idx += 1) {
41463 PyObject* val = PyInt_FromLong( result->Item(idx) );
41464 PyList_Append(resultobj, val);
41465 Py_DECREF(val);
41466 }
41467 }
41468 return resultobj;
41469 fail:
41470 return NULL;
41471 }
41472
41473
41474 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41475 PyObject *obj;
41476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41477 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41478 Py_INCREF(obj);
41479 return Py_BuildValue((char *)"");
41480 }
41481 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj;
41483 wxStdDialogButtonSizer *result;
41484 char *kwnames[] = {
41485 NULL
41486 };
41487
41488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41489 {
41490 PyThreadState* __tstate = wxPyBeginAllowThreads();
41491 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41492
41493 wxPyEndAllowThreads(__tstate);
41494 if (PyErr_Occurred()) SWIG_fail;
41495 }
41496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41497 return resultobj;
41498 fail:
41499 return NULL;
41500 }
41501
41502
41503 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41504 PyObject *resultobj;
41505 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41506 wxButton *arg2 = (wxButton *) 0 ;
41507 PyObject * obj0 = 0 ;
41508 PyObject * obj1 = 0 ;
41509 char *kwnames[] = {
41510 (char *) "self",(char *) "button", NULL
41511 };
41512
41513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41515 if (SWIG_arg_fail(1)) SWIG_fail;
41516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41517 if (SWIG_arg_fail(2)) SWIG_fail;
41518 {
41519 PyThreadState* __tstate = wxPyBeginAllowThreads();
41520 (arg1)->AddButton(arg2);
41521
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 Py_INCREF(Py_None); resultobj = Py_None;
41526 return resultobj;
41527 fail:
41528 return NULL;
41529 }
41530
41531
41532 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41533 PyObject *resultobj;
41534 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41535 PyObject * obj0 = 0 ;
41536 char *kwnames[] = {
41537 (char *) "self", NULL
41538 };
41539
41540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41542 if (SWIG_arg_fail(1)) SWIG_fail;
41543 {
41544 PyThreadState* __tstate = wxPyBeginAllowThreads();
41545 (arg1)->Realize();
41546
41547 wxPyEndAllowThreads(__tstate);
41548 if (PyErr_Occurred()) SWIG_fail;
41549 }
41550 Py_INCREF(Py_None); resultobj = Py_None;
41551 return resultobj;
41552 fail:
41553 return NULL;
41554 }
41555
41556
41557 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41558 PyObject *resultobj;
41559 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41560 wxButton *arg2 = (wxButton *) 0 ;
41561 PyObject * obj0 = 0 ;
41562 PyObject * obj1 = 0 ;
41563 char *kwnames[] = {
41564 (char *) "self",(char *) "button", NULL
41565 };
41566
41567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41569 if (SWIG_arg_fail(1)) SWIG_fail;
41570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41571 if (SWIG_arg_fail(2)) SWIG_fail;
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 (arg1)->SetAffirmativeButton(arg2);
41575
41576 wxPyEndAllowThreads(__tstate);
41577 if (PyErr_Occurred()) SWIG_fail;
41578 }
41579 Py_INCREF(Py_None); resultobj = Py_None;
41580 return resultobj;
41581 fail:
41582 return NULL;
41583 }
41584
41585
41586 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41587 PyObject *resultobj;
41588 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41589 wxButton *arg2 = (wxButton *) 0 ;
41590 PyObject * obj0 = 0 ;
41591 PyObject * obj1 = 0 ;
41592 char *kwnames[] = {
41593 (char *) "self",(char *) "button", NULL
41594 };
41595
41596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41598 if (SWIG_arg_fail(1)) SWIG_fail;
41599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41600 if (SWIG_arg_fail(2)) SWIG_fail;
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 (arg1)->SetNegativeButton(arg2);
41604
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 Py_INCREF(Py_None); resultobj = Py_None;
41609 return resultobj;
41610 fail:
41611 return NULL;
41612 }
41613
41614
41615 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41616 PyObject *resultobj;
41617 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41618 wxButton *arg2 = (wxButton *) 0 ;
41619 PyObject * obj0 = 0 ;
41620 PyObject * obj1 = 0 ;
41621 char *kwnames[] = {
41622 (char *) "self",(char *) "button", NULL
41623 };
41624
41625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41627 if (SWIG_arg_fail(1)) SWIG_fail;
41628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41629 if (SWIG_arg_fail(2)) SWIG_fail;
41630 {
41631 PyThreadState* __tstate = wxPyBeginAllowThreads();
41632 (arg1)->SetCancelButton(arg2);
41633
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 Py_INCREF(Py_None); resultobj = Py_None;
41638 return resultobj;
41639 fail:
41640 return NULL;
41641 }
41642
41643
41644 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41645 PyObject *resultobj;
41646 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41647 wxButton *result;
41648 PyObject * obj0 = 0 ;
41649 char *kwnames[] = {
41650 (char *) "self", NULL
41651 };
41652
41653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41655 if (SWIG_arg_fail(1)) SWIG_fail;
41656 {
41657 PyThreadState* __tstate = wxPyBeginAllowThreads();
41658 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41659
41660 wxPyEndAllowThreads(__tstate);
41661 if (PyErr_Occurred()) SWIG_fail;
41662 }
41663 {
41664 resultobj = wxPyMake_wxObject(result, 0);
41665 }
41666 return resultobj;
41667 fail:
41668 return NULL;
41669 }
41670
41671
41672 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj;
41674 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41675 wxButton *result;
41676 PyObject * obj0 = 0 ;
41677 char *kwnames[] = {
41678 (char *) "self", NULL
41679 };
41680
41681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41683 if (SWIG_arg_fail(1)) SWIG_fail;
41684 {
41685 PyThreadState* __tstate = wxPyBeginAllowThreads();
41686 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41687
41688 wxPyEndAllowThreads(__tstate);
41689 if (PyErr_Occurred()) SWIG_fail;
41690 }
41691 {
41692 resultobj = wxPyMake_wxObject(result, 0);
41693 }
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj;
41702 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41703 wxButton *result;
41704 PyObject * obj0 = 0 ;
41705 char *kwnames[] = {
41706 (char *) "self", NULL
41707 };
41708
41709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41711 if (SWIG_arg_fail(1)) SWIG_fail;
41712 {
41713 PyThreadState* __tstate = wxPyBeginAllowThreads();
41714 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41715
41716 wxPyEndAllowThreads(__tstate);
41717 if (PyErr_Occurred()) SWIG_fail;
41718 }
41719 {
41720 resultobj = wxPyMake_wxObject(result, 0);
41721 }
41722 return resultobj;
41723 fail:
41724 return NULL;
41725 }
41726
41727
41728 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41729 PyObject *resultobj;
41730 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41731 wxButton *result;
41732 PyObject * obj0 = 0 ;
41733 char *kwnames[] = {
41734 (char *) "self", NULL
41735 };
41736
41737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41739 if (SWIG_arg_fail(1)) SWIG_fail;
41740 {
41741 PyThreadState* __tstate = wxPyBeginAllowThreads();
41742 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41743
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 {
41748 resultobj = wxPyMake_wxObject(result, 0);
41749 }
41750 return resultobj;
41751 fail:
41752 return NULL;
41753 }
41754
41755
41756 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41757 PyObject *resultobj;
41758 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41759 wxButton *result;
41760 PyObject * obj0 = 0 ;
41761 char *kwnames[] = {
41762 (char *) "self", NULL
41763 };
41764
41765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41767 if (SWIG_arg_fail(1)) SWIG_fail;
41768 {
41769 PyThreadState* __tstate = wxPyBeginAllowThreads();
41770 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41771
41772 wxPyEndAllowThreads(__tstate);
41773 if (PyErr_Occurred()) SWIG_fail;
41774 }
41775 {
41776 resultobj = wxPyMake_wxObject(result, 0);
41777 }
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41785 PyObject *obj;
41786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41787 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41788 Py_INCREF(obj);
41789 return Py_BuildValue((char *)"");
41790 }
41791 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41792 PyObject *resultobj;
41793 int arg1 = (int) 0 ;
41794 int arg2 = (int) 0 ;
41795 wxGBPosition *result;
41796 PyObject * obj0 = 0 ;
41797 PyObject * obj1 = 0 ;
41798 char *kwnames[] = {
41799 (char *) "row",(char *) "col", NULL
41800 };
41801
41802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41803 if (obj0) {
41804 {
41805 arg1 = (int)(SWIG_As_int(obj0));
41806 if (SWIG_arg_fail(1)) SWIG_fail;
41807 }
41808 }
41809 if (obj1) {
41810 {
41811 arg2 = (int)(SWIG_As_int(obj1));
41812 if (SWIG_arg_fail(2)) SWIG_fail;
41813 }
41814 }
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41818
41819 wxPyEndAllowThreads(__tstate);
41820 if (PyErr_Occurred()) SWIG_fail;
41821 }
41822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj;
41831 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41832 int result;
41833 PyObject * obj0 = 0 ;
41834 char *kwnames[] = {
41835 (char *) "self", NULL
41836 };
41837
41838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41840 if (SWIG_arg_fail(1)) SWIG_fail;
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 result = (int)((wxGBPosition const *)arg1)->GetRow();
41844
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 {
41849 resultobj = SWIG_From_int((int)(result));
41850 }
41851 return resultobj;
41852 fail:
41853 return NULL;
41854 }
41855
41856
41857 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41858 PyObject *resultobj;
41859 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41860 int result;
41861 PyObject * obj0 = 0 ;
41862 char *kwnames[] = {
41863 (char *) "self", NULL
41864 };
41865
41866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41868 if (SWIG_arg_fail(1)) SWIG_fail;
41869 {
41870 PyThreadState* __tstate = wxPyBeginAllowThreads();
41871 result = (int)((wxGBPosition const *)arg1)->GetCol();
41872
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 {
41877 resultobj = SWIG_From_int((int)(result));
41878 }
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj;
41887 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41888 int arg2 ;
41889 PyObject * obj0 = 0 ;
41890 PyObject * obj1 = 0 ;
41891 char *kwnames[] = {
41892 (char *) "self",(char *) "row", NULL
41893 };
41894
41895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41897 if (SWIG_arg_fail(1)) SWIG_fail;
41898 {
41899 arg2 = (int)(SWIG_As_int(obj1));
41900 if (SWIG_arg_fail(2)) SWIG_fail;
41901 }
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 (arg1)->SetRow(arg2);
41905
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 Py_INCREF(Py_None); resultobj = Py_None;
41910 return resultobj;
41911 fail:
41912 return NULL;
41913 }
41914
41915
41916 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41917 PyObject *resultobj;
41918 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41919 int arg2 ;
41920 PyObject * obj0 = 0 ;
41921 PyObject * obj1 = 0 ;
41922 char *kwnames[] = {
41923 (char *) "self",(char *) "col", NULL
41924 };
41925
41926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41928 if (SWIG_arg_fail(1)) SWIG_fail;
41929 {
41930 arg2 = (int)(SWIG_As_int(obj1));
41931 if (SWIG_arg_fail(2)) SWIG_fail;
41932 }
41933 {
41934 PyThreadState* __tstate = wxPyBeginAllowThreads();
41935 (arg1)->SetCol(arg2);
41936
41937 wxPyEndAllowThreads(__tstate);
41938 if (PyErr_Occurred()) SWIG_fail;
41939 }
41940 Py_INCREF(Py_None); resultobj = Py_None;
41941 return resultobj;
41942 fail:
41943 return NULL;
41944 }
41945
41946
41947 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41948 PyObject *resultobj;
41949 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41950 wxGBPosition *arg2 = 0 ;
41951 bool result;
41952 wxGBPosition temp2 ;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 char *kwnames[] = {
41956 (char *) "self",(char *) "other", NULL
41957 };
41958
41959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41961 if (SWIG_arg_fail(1)) SWIG_fail;
41962 {
41963 arg2 = &temp2;
41964 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41965 }
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41969
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41975 }
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj;
41984 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41985 wxGBPosition *arg2 = 0 ;
41986 bool result;
41987 wxGBPosition temp2 ;
41988 PyObject * obj0 = 0 ;
41989 PyObject * obj1 = 0 ;
41990 char *kwnames[] = {
41991 (char *) "self",(char *) "other", NULL
41992 };
41993
41994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41996 if (SWIG_arg_fail(1)) SWIG_fail;
41997 {
41998 arg2 = &temp2;
41999 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42000 }
42001 {
42002 PyThreadState* __tstate = wxPyBeginAllowThreads();
42003 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42004
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 {
42009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42010 }
42011 return resultobj;
42012 fail:
42013 return NULL;
42014 }
42015
42016
42017 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42018 PyObject *resultobj;
42019 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42020 int arg2 = (int) 0 ;
42021 int arg3 = (int) 0 ;
42022 PyObject * obj0 = 0 ;
42023 PyObject * obj1 = 0 ;
42024 PyObject * obj2 = 0 ;
42025 char *kwnames[] = {
42026 (char *) "self",(char *) "row",(char *) "col", NULL
42027 };
42028
42029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42031 if (SWIG_arg_fail(1)) SWIG_fail;
42032 if (obj1) {
42033 {
42034 arg2 = (int)(SWIG_As_int(obj1));
42035 if (SWIG_arg_fail(2)) SWIG_fail;
42036 }
42037 }
42038 if (obj2) {
42039 {
42040 arg3 = (int)(SWIG_As_int(obj2));
42041 if (SWIG_arg_fail(3)) SWIG_fail;
42042 }
42043 }
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 wxGBPosition_Set(arg1,arg2,arg3);
42047
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 Py_INCREF(Py_None); resultobj = Py_None;
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42059 PyObject *resultobj;
42060 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42061 PyObject *result;
42062 PyObject * obj0 = 0 ;
42063 char *kwnames[] = {
42064 (char *) "self", NULL
42065 };
42066
42067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42069 if (SWIG_arg_fail(1)) SWIG_fail;
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 result = (PyObject *)wxGBPosition_Get(arg1);
42073
42074 wxPyEndAllowThreads(__tstate);
42075 if (PyErr_Occurred()) SWIG_fail;
42076 }
42077 resultobj = result;
42078 return resultobj;
42079 fail:
42080 return NULL;
42081 }
42082
42083
42084 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42085 PyObject *obj;
42086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42087 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42088 Py_INCREF(obj);
42089 return Py_BuildValue((char *)"");
42090 }
42091 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42092 PyObject *resultobj;
42093 int arg1 = (int) 1 ;
42094 int arg2 = (int) 1 ;
42095 wxGBSpan *result;
42096 PyObject * obj0 = 0 ;
42097 PyObject * obj1 = 0 ;
42098 char *kwnames[] = {
42099 (char *) "rowspan",(char *) "colspan", NULL
42100 };
42101
42102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42103 if (obj0) {
42104 {
42105 arg1 = (int)(SWIG_As_int(obj0));
42106 if (SWIG_arg_fail(1)) SWIG_fail;
42107 }
42108 }
42109 if (obj1) {
42110 {
42111 arg2 = (int)(SWIG_As_int(obj1));
42112 if (SWIG_arg_fail(2)) SWIG_fail;
42113 }
42114 }
42115 {
42116 PyThreadState* __tstate = wxPyBeginAllowThreads();
42117 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42118
42119 wxPyEndAllowThreads(__tstate);
42120 if (PyErr_Occurred()) SWIG_fail;
42121 }
42122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42123 return resultobj;
42124 fail:
42125 return NULL;
42126 }
42127
42128
42129 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42130 PyObject *resultobj;
42131 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42132 int result;
42133 PyObject * obj0 = 0 ;
42134 char *kwnames[] = {
42135 (char *) "self", NULL
42136 };
42137
42138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42140 if (SWIG_arg_fail(1)) SWIG_fail;
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42144
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 resultobj = SWIG_From_int((int)(result));
42150 }
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj;
42159 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42160 int result;
42161 PyObject * obj0 = 0 ;
42162 char *kwnames[] = {
42163 (char *) "self", NULL
42164 };
42165
42166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42168 if (SWIG_arg_fail(1)) SWIG_fail;
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42172
42173 wxPyEndAllowThreads(__tstate);
42174 if (PyErr_Occurred()) SWIG_fail;
42175 }
42176 {
42177 resultobj = SWIG_From_int((int)(result));
42178 }
42179 return resultobj;
42180 fail:
42181 return NULL;
42182 }
42183
42184
42185 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42186 PyObject *resultobj;
42187 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42188 int arg2 ;
42189 PyObject * obj0 = 0 ;
42190 PyObject * obj1 = 0 ;
42191 char *kwnames[] = {
42192 (char *) "self",(char *) "rowspan", NULL
42193 };
42194
42195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42197 if (SWIG_arg_fail(1)) SWIG_fail;
42198 {
42199 arg2 = (int)(SWIG_As_int(obj1));
42200 if (SWIG_arg_fail(2)) SWIG_fail;
42201 }
42202 {
42203 PyThreadState* __tstate = wxPyBeginAllowThreads();
42204 (arg1)->SetRowspan(arg2);
42205
42206 wxPyEndAllowThreads(__tstate);
42207 if (PyErr_Occurred()) SWIG_fail;
42208 }
42209 Py_INCREF(Py_None); resultobj = Py_None;
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj;
42218 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42219 int arg2 ;
42220 PyObject * obj0 = 0 ;
42221 PyObject * obj1 = 0 ;
42222 char *kwnames[] = {
42223 (char *) "self",(char *) "colspan", NULL
42224 };
42225
42226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42228 if (SWIG_arg_fail(1)) SWIG_fail;
42229 {
42230 arg2 = (int)(SWIG_As_int(obj1));
42231 if (SWIG_arg_fail(2)) SWIG_fail;
42232 }
42233 {
42234 PyThreadState* __tstate = wxPyBeginAllowThreads();
42235 (arg1)->SetColspan(arg2);
42236
42237 wxPyEndAllowThreads(__tstate);
42238 if (PyErr_Occurred()) SWIG_fail;
42239 }
42240 Py_INCREF(Py_None); resultobj = Py_None;
42241 return resultobj;
42242 fail:
42243 return NULL;
42244 }
42245
42246
42247 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42248 PyObject *resultobj;
42249 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42250 wxGBSpan *arg2 = 0 ;
42251 bool result;
42252 wxGBSpan temp2 ;
42253 PyObject * obj0 = 0 ;
42254 PyObject * obj1 = 0 ;
42255 char *kwnames[] = {
42256 (char *) "self",(char *) "other", NULL
42257 };
42258
42259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42261 if (SWIG_arg_fail(1)) SWIG_fail;
42262 {
42263 arg2 = &temp2;
42264 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42265 }
42266 {
42267 PyThreadState* __tstate = wxPyBeginAllowThreads();
42268 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42269
42270 wxPyEndAllowThreads(__tstate);
42271 if (PyErr_Occurred()) SWIG_fail;
42272 }
42273 {
42274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42275 }
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj;
42284 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42285 wxGBSpan *arg2 = 0 ;
42286 bool result;
42287 wxGBSpan temp2 ;
42288 PyObject * obj0 = 0 ;
42289 PyObject * obj1 = 0 ;
42290 char *kwnames[] = {
42291 (char *) "self",(char *) "other", NULL
42292 };
42293
42294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42296 if (SWIG_arg_fail(1)) SWIG_fail;
42297 {
42298 arg2 = &temp2;
42299 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42300 }
42301 {
42302 PyThreadState* __tstate = wxPyBeginAllowThreads();
42303 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42304
42305 wxPyEndAllowThreads(__tstate);
42306 if (PyErr_Occurred()) SWIG_fail;
42307 }
42308 {
42309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42310 }
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42318 PyObject *resultobj;
42319 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42320 int arg2 = (int) 1 ;
42321 int arg3 = (int) 1 ;
42322 PyObject * obj0 = 0 ;
42323 PyObject * obj1 = 0 ;
42324 PyObject * obj2 = 0 ;
42325 char *kwnames[] = {
42326 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42327 };
42328
42329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42331 if (SWIG_arg_fail(1)) SWIG_fail;
42332 if (obj1) {
42333 {
42334 arg2 = (int)(SWIG_As_int(obj1));
42335 if (SWIG_arg_fail(2)) SWIG_fail;
42336 }
42337 }
42338 if (obj2) {
42339 {
42340 arg3 = (int)(SWIG_As_int(obj2));
42341 if (SWIG_arg_fail(3)) SWIG_fail;
42342 }
42343 }
42344 {
42345 PyThreadState* __tstate = wxPyBeginAllowThreads();
42346 wxGBSpan_Set(arg1,arg2,arg3);
42347
42348 wxPyEndAllowThreads(__tstate);
42349 if (PyErr_Occurred()) SWIG_fail;
42350 }
42351 Py_INCREF(Py_None); resultobj = Py_None;
42352 return resultobj;
42353 fail:
42354 return NULL;
42355 }
42356
42357
42358 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42359 PyObject *resultobj;
42360 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42361 PyObject *result;
42362 PyObject * obj0 = 0 ;
42363 char *kwnames[] = {
42364 (char *) "self", NULL
42365 };
42366
42367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42369 if (SWIG_arg_fail(1)) SWIG_fail;
42370 {
42371 PyThreadState* __tstate = wxPyBeginAllowThreads();
42372 result = (PyObject *)wxGBSpan_Get(arg1);
42373
42374 wxPyEndAllowThreads(__tstate);
42375 if (PyErr_Occurred()) SWIG_fail;
42376 }
42377 resultobj = result;
42378 return resultobj;
42379 fail:
42380 return NULL;
42381 }
42382
42383
42384 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42385 PyObject *obj;
42386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42387 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42388 Py_INCREF(obj);
42389 return Py_BuildValue((char *)"");
42390 }
42391 static int _wrap_DefaultSpan_set(PyObject *) {
42392 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42393 return 1;
42394 }
42395
42396
42397 static PyObject *_wrap_DefaultSpan_get(void) {
42398 PyObject *pyobj;
42399
42400 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42401 return pyobj;
42402 }
42403
42404
42405 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42406 PyObject *resultobj;
42407 wxGBSizerItem *result;
42408 char *kwnames[] = {
42409 NULL
42410 };
42411
42412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 result = (wxGBSizerItem *)new wxGBSizerItem();
42416
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj;
42429 wxWindow *arg1 = (wxWindow *) 0 ;
42430 wxGBPosition *arg2 = 0 ;
42431 wxGBSpan *arg3 = 0 ;
42432 int arg4 ;
42433 int arg5 ;
42434 PyObject *arg6 = (PyObject *) NULL ;
42435 wxGBSizerItem *result;
42436 wxGBPosition temp2 ;
42437 wxGBSpan temp3 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 PyObject * obj2 = 0 ;
42441 PyObject * obj3 = 0 ;
42442 PyObject * obj4 = 0 ;
42443 PyObject * obj5 = 0 ;
42444 char *kwnames[] = {
42445 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42446 };
42447
42448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42450 if (SWIG_arg_fail(1)) SWIG_fail;
42451 {
42452 arg2 = &temp2;
42453 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42454 }
42455 {
42456 arg3 = &temp3;
42457 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42458 }
42459 {
42460 arg4 = (int)(SWIG_As_int(obj3));
42461 if (SWIG_arg_fail(4)) SWIG_fail;
42462 }
42463 {
42464 arg5 = (int)(SWIG_As_int(obj4));
42465 if (SWIG_arg_fail(5)) SWIG_fail;
42466 }
42467 if (obj5) {
42468 arg6 = obj5;
42469 }
42470 {
42471 PyThreadState* __tstate = wxPyBeginAllowThreads();
42472 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42473
42474 wxPyEndAllowThreads(__tstate);
42475 if (PyErr_Occurred()) SWIG_fail;
42476 }
42477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42478 return resultobj;
42479 fail:
42480 return NULL;
42481 }
42482
42483
42484 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42485 PyObject *resultobj;
42486 wxSizer *arg1 = (wxSizer *) 0 ;
42487 wxGBPosition *arg2 = 0 ;
42488 wxGBSpan *arg3 = 0 ;
42489 int arg4 ;
42490 int arg5 ;
42491 PyObject *arg6 = (PyObject *) NULL ;
42492 wxGBSizerItem *result;
42493 wxGBPosition temp2 ;
42494 wxGBSpan temp3 ;
42495 PyObject * obj0 = 0 ;
42496 PyObject * obj1 = 0 ;
42497 PyObject * obj2 = 0 ;
42498 PyObject * obj3 = 0 ;
42499 PyObject * obj4 = 0 ;
42500 PyObject * obj5 = 0 ;
42501 char *kwnames[] = {
42502 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42503 };
42504
42505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42507 if (SWIG_arg_fail(1)) SWIG_fail;
42508 {
42509 arg2 = &temp2;
42510 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42511 }
42512 {
42513 arg3 = &temp3;
42514 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42515 }
42516 {
42517 arg4 = (int)(SWIG_As_int(obj3));
42518 if (SWIG_arg_fail(4)) SWIG_fail;
42519 }
42520 {
42521 arg5 = (int)(SWIG_As_int(obj4));
42522 if (SWIG_arg_fail(5)) SWIG_fail;
42523 }
42524 if (obj5) {
42525 arg6 = obj5;
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42530
42531 wxPyEndAllowThreads(__tstate);
42532 if (PyErr_Occurred()) SWIG_fail;
42533 }
42534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42535 return resultobj;
42536 fail:
42537 return NULL;
42538 }
42539
42540
42541 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42542 PyObject *resultobj;
42543 int arg1 ;
42544 int arg2 ;
42545 wxGBPosition *arg3 = 0 ;
42546 wxGBSpan *arg4 = 0 ;
42547 int arg5 ;
42548 int arg6 ;
42549 PyObject *arg7 = (PyObject *) NULL ;
42550 wxGBSizerItem *result;
42551 wxGBPosition temp3 ;
42552 wxGBSpan temp4 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 PyObject * obj2 = 0 ;
42556 PyObject * obj3 = 0 ;
42557 PyObject * obj4 = 0 ;
42558 PyObject * obj5 = 0 ;
42559 PyObject * obj6 = 0 ;
42560 char *kwnames[] = {
42561 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42562 };
42563
42564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42565 {
42566 arg1 = (int)(SWIG_As_int(obj0));
42567 if (SWIG_arg_fail(1)) SWIG_fail;
42568 }
42569 {
42570 arg2 = (int)(SWIG_As_int(obj1));
42571 if (SWIG_arg_fail(2)) SWIG_fail;
42572 }
42573 {
42574 arg3 = &temp3;
42575 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42576 }
42577 {
42578 arg4 = &temp4;
42579 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42580 }
42581 {
42582 arg5 = (int)(SWIG_As_int(obj4));
42583 if (SWIG_arg_fail(5)) SWIG_fail;
42584 }
42585 {
42586 arg6 = (int)(SWIG_As_int(obj5));
42587 if (SWIG_arg_fail(6)) SWIG_fail;
42588 }
42589 if (obj6) {
42590 arg7 = obj6;
42591 }
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42595
42596 wxPyEndAllowThreads(__tstate);
42597 if (PyErr_Occurred()) SWIG_fail;
42598 }
42599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42600 return resultobj;
42601 fail:
42602 return NULL;
42603 }
42604
42605
42606 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42607 PyObject *resultobj;
42608 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42609 wxGBPosition result;
42610 PyObject * obj0 = 0 ;
42611 char *kwnames[] = {
42612 (char *) "self", NULL
42613 };
42614
42615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42617 if (SWIG_arg_fail(1)) SWIG_fail;
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 result = ((wxGBSizerItem const *)arg1)->GetPos();
42621
42622 wxPyEndAllowThreads(__tstate);
42623 if (PyErr_Occurred()) SWIG_fail;
42624 }
42625 {
42626 wxGBPosition * resultptr;
42627 resultptr = new wxGBPosition((wxGBPosition &)(result));
42628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42629 }
42630 return resultobj;
42631 fail:
42632 return NULL;
42633 }
42634
42635
42636 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42637 PyObject *resultobj;
42638 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42639 wxGBSpan result;
42640 PyObject * obj0 = 0 ;
42641 char *kwnames[] = {
42642 (char *) "self", NULL
42643 };
42644
42645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42647 if (SWIG_arg_fail(1)) SWIG_fail;
42648 {
42649 PyThreadState* __tstate = wxPyBeginAllowThreads();
42650 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42651
42652 wxPyEndAllowThreads(__tstate);
42653 if (PyErr_Occurred()) SWIG_fail;
42654 }
42655 {
42656 wxGBSpan * resultptr;
42657 resultptr = new wxGBSpan((wxGBSpan &)(result));
42658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42659 }
42660 return resultobj;
42661 fail:
42662 return NULL;
42663 }
42664
42665
42666 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42667 PyObject *resultobj;
42668 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42669 wxGBPosition *arg2 = 0 ;
42670 bool result;
42671 wxGBPosition temp2 ;
42672 PyObject * obj0 = 0 ;
42673 PyObject * obj1 = 0 ;
42674 char *kwnames[] = {
42675 (char *) "self",(char *) "pos", NULL
42676 };
42677
42678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42680 if (SWIG_arg_fail(1)) SWIG_fail;
42681 {
42682 arg2 = &temp2;
42683 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42684 }
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42688
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42694 }
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42702 PyObject *resultobj;
42703 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42704 wxGBSpan *arg2 = 0 ;
42705 bool result;
42706 wxGBSpan temp2 ;
42707 PyObject * obj0 = 0 ;
42708 PyObject * obj1 = 0 ;
42709 char *kwnames[] = {
42710 (char *) "self",(char *) "span", NULL
42711 };
42712
42713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42715 if (SWIG_arg_fail(1)) SWIG_fail;
42716 {
42717 arg2 = &temp2;
42718 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42719 }
42720 {
42721 PyThreadState* __tstate = wxPyBeginAllowThreads();
42722 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42723
42724 wxPyEndAllowThreads(__tstate);
42725 if (PyErr_Occurred()) SWIG_fail;
42726 }
42727 {
42728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42729 }
42730 return resultobj;
42731 fail:
42732 return NULL;
42733 }
42734
42735
42736 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42737 PyObject *resultobj;
42738 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42739 wxGBSizerItem *arg2 = 0 ;
42740 bool result;
42741 PyObject * obj0 = 0 ;
42742 PyObject * obj1 = 0 ;
42743 char *kwnames[] = {
42744 (char *) "self",(char *) "other", NULL
42745 };
42746
42747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42749 if (SWIG_arg_fail(1)) SWIG_fail;
42750 {
42751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42752 if (SWIG_arg_fail(2)) SWIG_fail;
42753 if (arg2 == NULL) {
42754 SWIG_null_ref("wxGBSizerItem");
42755 }
42756 if (SWIG_arg_fail(2)) SWIG_fail;
42757 }
42758 {
42759 PyThreadState* __tstate = wxPyBeginAllowThreads();
42760 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42761
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 {
42766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42767 }
42768 return resultobj;
42769 fail:
42770 return NULL;
42771 }
42772
42773
42774 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42775 PyObject *resultobj;
42776 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42777 wxGBPosition *arg2 = 0 ;
42778 wxGBSpan *arg3 = 0 ;
42779 bool result;
42780 wxGBPosition temp2 ;
42781 wxGBSpan temp3 ;
42782 PyObject * obj0 = 0 ;
42783 PyObject * obj1 = 0 ;
42784 PyObject * obj2 = 0 ;
42785 char *kwnames[] = {
42786 (char *) "self",(char *) "pos",(char *) "span", NULL
42787 };
42788
42789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42791 if (SWIG_arg_fail(1)) SWIG_fail;
42792 {
42793 arg2 = &temp2;
42794 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42795 }
42796 {
42797 arg3 = &temp3;
42798 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42799 }
42800 {
42801 PyThreadState* __tstate = wxPyBeginAllowThreads();
42802 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42803
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 {
42808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42809 }
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42817 PyObject *resultobj;
42818 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42819 wxGBPosition result;
42820 PyObject * obj0 = 0 ;
42821 char *kwnames[] = {
42822 (char *) "self", NULL
42823 };
42824
42825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42827 if (SWIG_arg_fail(1)) SWIG_fail;
42828 {
42829 PyThreadState* __tstate = wxPyBeginAllowThreads();
42830 result = wxGBSizerItem_GetEndPos(arg1);
42831
42832 wxPyEndAllowThreads(__tstate);
42833 if (PyErr_Occurred()) SWIG_fail;
42834 }
42835 {
42836 wxGBPosition * resultptr;
42837 resultptr = new wxGBPosition((wxGBPosition &)(result));
42838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42847 PyObject *resultobj;
42848 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42849 wxGridBagSizer *result;
42850 PyObject * obj0 = 0 ;
42851 char *kwnames[] = {
42852 (char *) "self", NULL
42853 };
42854
42855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42857 if (SWIG_arg_fail(1)) SWIG_fail;
42858 {
42859 PyThreadState* __tstate = wxPyBeginAllowThreads();
42860 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42861
42862 wxPyEndAllowThreads(__tstate);
42863 if (PyErr_Occurred()) SWIG_fail;
42864 }
42865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42866 return resultobj;
42867 fail:
42868 return NULL;
42869 }
42870
42871
42872 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42873 PyObject *resultobj;
42874 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42875 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42876 PyObject * obj0 = 0 ;
42877 PyObject * obj1 = 0 ;
42878 char *kwnames[] = {
42879 (char *) "self",(char *) "sizer", NULL
42880 };
42881
42882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42884 if (SWIG_arg_fail(1)) SWIG_fail;
42885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42886 if (SWIG_arg_fail(2)) SWIG_fail;
42887 {
42888 PyThreadState* __tstate = wxPyBeginAllowThreads();
42889 (arg1)->SetGBSizer(arg2);
42890
42891 wxPyEndAllowThreads(__tstate);
42892 if (PyErr_Occurred()) SWIG_fail;
42893 }
42894 Py_INCREF(Py_None); resultobj = Py_None;
42895 return resultobj;
42896 fail:
42897 return NULL;
42898 }
42899
42900
42901 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42902 PyObject *obj;
42903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42904 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42905 Py_INCREF(obj);
42906 return Py_BuildValue((char *)"");
42907 }
42908 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42909 PyObject *resultobj;
42910 int arg1 = (int) 0 ;
42911 int arg2 = (int) 0 ;
42912 wxGridBagSizer *result;
42913 PyObject * obj0 = 0 ;
42914 PyObject * obj1 = 0 ;
42915 char *kwnames[] = {
42916 (char *) "vgap",(char *) "hgap", NULL
42917 };
42918
42919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42920 if (obj0) {
42921 {
42922 arg1 = (int)(SWIG_As_int(obj0));
42923 if (SWIG_arg_fail(1)) SWIG_fail;
42924 }
42925 }
42926 if (obj1) {
42927 {
42928 arg2 = (int)(SWIG_As_int(obj1));
42929 if (SWIG_arg_fail(2)) SWIG_fail;
42930 }
42931 }
42932 {
42933 PyThreadState* __tstate = wxPyBeginAllowThreads();
42934 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42935
42936 wxPyEndAllowThreads(__tstate);
42937 if (PyErr_Occurred()) SWIG_fail;
42938 }
42939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42940 return resultobj;
42941 fail:
42942 return NULL;
42943 }
42944
42945
42946 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42947 PyObject *resultobj;
42948 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42949 PyObject *arg2 = (PyObject *) 0 ;
42950 wxGBPosition *arg3 = 0 ;
42951 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42952 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42953 int arg5 = (int) 0 ;
42954 int arg6 = (int) 0 ;
42955 PyObject *arg7 = (PyObject *) NULL ;
42956 wxGBSizerItem *result;
42957 wxGBPosition temp3 ;
42958 wxGBSpan temp4 ;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961 PyObject * obj2 = 0 ;
42962 PyObject * obj3 = 0 ;
42963 PyObject * obj4 = 0 ;
42964 PyObject * obj5 = 0 ;
42965 PyObject * obj6 = 0 ;
42966 char *kwnames[] = {
42967 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42968 };
42969
42970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42972 if (SWIG_arg_fail(1)) SWIG_fail;
42973 arg2 = obj1;
42974 {
42975 arg3 = &temp3;
42976 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42977 }
42978 if (obj3) {
42979 {
42980 arg4 = &temp4;
42981 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42982 }
42983 }
42984 if (obj4) {
42985 {
42986 arg5 = (int)(SWIG_As_int(obj4));
42987 if (SWIG_arg_fail(5)) SWIG_fail;
42988 }
42989 }
42990 if (obj5) {
42991 {
42992 arg6 = (int)(SWIG_As_int(obj5));
42993 if (SWIG_arg_fail(6)) SWIG_fail;
42994 }
42995 }
42996 if (obj6) {
42997 arg7 = obj6;
42998 }
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43002
43003 wxPyEndAllowThreads(__tstate);
43004 if (PyErr_Occurred()) SWIG_fail;
43005 }
43006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43007 return resultobj;
43008 fail:
43009 return NULL;
43010 }
43011
43012
43013 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43014 PyObject *resultobj;
43015 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43016 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43017 wxGBSizerItem *result;
43018 PyObject * obj0 = 0 ;
43019 PyObject * obj1 = 0 ;
43020 char *kwnames[] = {
43021 (char *) "self",(char *) "item", NULL
43022 };
43023
43024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43026 if (SWIG_arg_fail(1)) SWIG_fail;
43027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43028 if (SWIG_arg_fail(2)) SWIG_fail;
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43032
43033 wxPyEndAllowThreads(__tstate);
43034 if (PyErr_Occurred()) SWIG_fail;
43035 }
43036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43037 return resultobj;
43038 fail:
43039 return NULL;
43040 }
43041
43042
43043 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43044 PyObject *resultobj;
43045 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43046 int arg2 ;
43047 int arg3 ;
43048 wxSize result;
43049 PyObject * obj0 = 0 ;
43050 PyObject * obj1 = 0 ;
43051 PyObject * obj2 = 0 ;
43052 char *kwnames[] = {
43053 (char *) "self",(char *) "row",(char *) "col", NULL
43054 };
43055
43056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43058 if (SWIG_arg_fail(1)) SWIG_fail;
43059 {
43060 arg2 = (int)(SWIG_As_int(obj1));
43061 if (SWIG_arg_fail(2)) SWIG_fail;
43062 }
43063 {
43064 arg3 = (int)(SWIG_As_int(obj2));
43065 if (SWIG_arg_fail(3)) SWIG_fail;
43066 }
43067 {
43068 PyThreadState* __tstate = wxPyBeginAllowThreads();
43069 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43070
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 {
43075 wxSize * resultptr;
43076 resultptr = new wxSize((wxSize &)(result));
43077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43078 }
43079 return resultobj;
43080 fail:
43081 return NULL;
43082 }
43083
43084
43085 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43086 PyObject *resultobj;
43087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43088 wxSize result;
43089 PyObject * obj0 = 0 ;
43090 char *kwnames[] = {
43091 (char *) "self", NULL
43092 };
43093
43094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43096 if (SWIG_arg_fail(1)) SWIG_fail;
43097 {
43098 PyThreadState* __tstate = wxPyBeginAllowThreads();
43099 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43100
43101 wxPyEndAllowThreads(__tstate);
43102 if (PyErr_Occurred()) SWIG_fail;
43103 }
43104 {
43105 wxSize * resultptr;
43106 resultptr = new wxSize((wxSize &)(result));
43107 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43108 }
43109 return resultobj;
43110 fail:
43111 return NULL;
43112 }
43113
43114
43115 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43116 PyObject *resultobj;
43117 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43118 wxSize *arg2 = 0 ;
43119 wxSize temp2 ;
43120 PyObject * obj0 = 0 ;
43121 PyObject * obj1 = 0 ;
43122 char *kwnames[] = {
43123 (char *) "self",(char *) "sz", NULL
43124 };
43125
43126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43128 if (SWIG_arg_fail(1)) SWIG_fail;
43129 {
43130 arg2 = &temp2;
43131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43132 }
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43136
43137 wxPyEndAllowThreads(__tstate);
43138 if (PyErr_Occurred()) SWIG_fail;
43139 }
43140 Py_INCREF(Py_None); resultobj = Py_None;
43141 return resultobj;
43142 fail:
43143 return NULL;
43144 }
43145
43146
43147 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43148 PyObject *resultobj;
43149 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43150 wxWindow *arg2 = (wxWindow *) 0 ;
43151 wxGBPosition result;
43152 PyObject * obj0 = 0 ;
43153 PyObject * obj1 = 0 ;
43154
43155 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43157 if (SWIG_arg_fail(1)) SWIG_fail;
43158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43159 if (SWIG_arg_fail(2)) SWIG_fail;
43160 {
43161 PyThreadState* __tstate = wxPyBeginAllowThreads();
43162 result = (arg1)->GetItemPosition(arg2);
43163
43164 wxPyEndAllowThreads(__tstate);
43165 if (PyErr_Occurred()) SWIG_fail;
43166 }
43167 {
43168 wxGBPosition * resultptr;
43169 resultptr = new wxGBPosition((wxGBPosition &)(result));
43170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43171 }
43172 return resultobj;
43173 fail:
43174 return NULL;
43175 }
43176
43177
43178 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43179 PyObject *resultobj;
43180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43181 wxSizer *arg2 = (wxSizer *) 0 ;
43182 wxGBPosition result;
43183 PyObject * obj0 = 0 ;
43184 PyObject * obj1 = 0 ;
43185
43186 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43188 if (SWIG_arg_fail(1)) SWIG_fail;
43189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43190 if (SWIG_arg_fail(2)) SWIG_fail;
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 result = (arg1)->GetItemPosition(arg2);
43194
43195 wxPyEndAllowThreads(__tstate);
43196 if (PyErr_Occurred()) SWIG_fail;
43197 }
43198 {
43199 wxGBPosition * resultptr;
43200 resultptr = new wxGBPosition((wxGBPosition &)(result));
43201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43202 }
43203 return resultobj;
43204 fail:
43205 return NULL;
43206 }
43207
43208
43209 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43210 PyObject *resultobj;
43211 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43212 size_t arg2 ;
43213 wxGBPosition result;
43214 PyObject * obj0 = 0 ;
43215 PyObject * obj1 = 0 ;
43216
43217 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43219 if (SWIG_arg_fail(1)) SWIG_fail;
43220 {
43221 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43222 if (SWIG_arg_fail(2)) SWIG_fail;
43223 }
43224 {
43225 PyThreadState* __tstate = wxPyBeginAllowThreads();
43226 result = (arg1)->GetItemPosition(arg2);
43227
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 {
43232 wxGBPosition * resultptr;
43233 resultptr = new wxGBPosition((wxGBPosition &)(result));
43234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43235 }
43236 return resultobj;
43237 fail:
43238 return NULL;
43239 }
43240
43241
43242 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43243 int argc;
43244 PyObject *argv[3];
43245 int ii;
43246
43247 argc = PyObject_Length(args);
43248 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43249 argv[ii] = PyTuple_GetItem(args,ii);
43250 }
43251 if (argc == 2) {
43252 int _v;
43253 {
43254 void *ptr;
43255 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43256 _v = 0;
43257 PyErr_Clear();
43258 } else {
43259 _v = 1;
43260 }
43261 }
43262 if (_v) {
43263 {
43264 void *ptr;
43265 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43266 _v = 0;
43267 PyErr_Clear();
43268 } else {
43269 _v = 1;
43270 }
43271 }
43272 if (_v) {
43273 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43274 }
43275 }
43276 }
43277 if (argc == 2) {
43278 int _v;
43279 {
43280 void *ptr;
43281 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43282 _v = 0;
43283 PyErr_Clear();
43284 } else {
43285 _v = 1;
43286 }
43287 }
43288 if (_v) {
43289 {
43290 void *ptr;
43291 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43292 _v = 0;
43293 PyErr_Clear();
43294 } else {
43295 _v = 1;
43296 }
43297 }
43298 if (_v) {
43299 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43300 }
43301 }
43302 }
43303 if (argc == 2) {
43304 int _v;
43305 {
43306 void *ptr;
43307 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43308 _v = 0;
43309 PyErr_Clear();
43310 } else {
43311 _v = 1;
43312 }
43313 }
43314 if (_v) {
43315 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43316 if (_v) {
43317 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43318 }
43319 }
43320 }
43321
43322 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43323 return NULL;
43324 }
43325
43326
43327 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43328 PyObject *resultobj;
43329 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43330 wxWindow *arg2 = (wxWindow *) 0 ;
43331 wxGBPosition *arg3 = 0 ;
43332 bool result;
43333 wxGBPosition temp3 ;
43334 PyObject * obj0 = 0 ;
43335 PyObject * obj1 = 0 ;
43336 PyObject * obj2 = 0 ;
43337
43338 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43340 if (SWIG_arg_fail(1)) SWIG_fail;
43341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43342 if (SWIG_arg_fail(2)) SWIG_fail;
43343 {
43344 arg3 = &temp3;
43345 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43346 }
43347 {
43348 PyThreadState* __tstate = wxPyBeginAllowThreads();
43349 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43350
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 {
43355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43356 }
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43364 PyObject *resultobj;
43365 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43366 wxSizer *arg2 = (wxSizer *) 0 ;
43367 wxGBPosition *arg3 = 0 ;
43368 bool result;
43369 wxGBPosition temp3 ;
43370 PyObject * obj0 = 0 ;
43371 PyObject * obj1 = 0 ;
43372 PyObject * obj2 = 0 ;
43373
43374 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43376 if (SWIG_arg_fail(1)) SWIG_fail;
43377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43378 if (SWIG_arg_fail(2)) SWIG_fail;
43379 {
43380 arg3 = &temp3;
43381 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43382 }
43383 {
43384 PyThreadState* __tstate = wxPyBeginAllowThreads();
43385 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43386
43387 wxPyEndAllowThreads(__tstate);
43388 if (PyErr_Occurred()) SWIG_fail;
43389 }
43390 {
43391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43392 }
43393 return resultobj;
43394 fail:
43395 return NULL;
43396 }
43397
43398
43399 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43400 PyObject *resultobj;
43401 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43402 size_t arg2 ;
43403 wxGBPosition *arg3 = 0 ;
43404 bool result;
43405 wxGBPosition temp3 ;
43406 PyObject * obj0 = 0 ;
43407 PyObject * obj1 = 0 ;
43408 PyObject * obj2 = 0 ;
43409
43410 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43412 if (SWIG_arg_fail(1)) SWIG_fail;
43413 {
43414 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43415 if (SWIG_arg_fail(2)) SWIG_fail;
43416 }
43417 {
43418 arg3 = &temp3;
43419 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43420 }
43421 {
43422 PyThreadState* __tstate = wxPyBeginAllowThreads();
43423 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43424
43425 wxPyEndAllowThreads(__tstate);
43426 if (PyErr_Occurred()) SWIG_fail;
43427 }
43428 {
43429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43430 }
43431 return resultobj;
43432 fail:
43433 return NULL;
43434 }
43435
43436
43437 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43438 int argc;
43439 PyObject *argv[4];
43440 int ii;
43441
43442 argc = PyObject_Length(args);
43443 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43444 argv[ii] = PyTuple_GetItem(args,ii);
43445 }
43446 if (argc == 3) {
43447 int _v;
43448 {
43449 void *ptr;
43450 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43451 _v = 0;
43452 PyErr_Clear();
43453 } else {
43454 _v = 1;
43455 }
43456 }
43457 if (_v) {
43458 {
43459 void *ptr;
43460 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43461 _v = 0;
43462 PyErr_Clear();
43463 } else {
43464 _v = 1;
43465 }
43466 }
43467 if (_v) {
43468 {
43469 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43470 }
43471 if (_v) {
43472 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43473 }
43474 }
43475 }
43476 }
43477 if (argc == 3) {
43478 int _v;
43479 {
43480 void *ptr;
43481 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43482 _v = 0;
43483 PyErr_Clear();
43484 } else {
43485 _v = 1;
43486 }
43487 }
43488 if (_v) {
43489 {
43490 void *ptr;
43491 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43492 _v = 0;
43493 PyErr_Clear();
43494 } else {
43495 _v = 1;
43496 }
43497 }
43498 if (_v) {
43499 {
43500 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43501 }
43502 if (_v) {
43503 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43504 }
43505 }
43506 }
43507 }
43508 if (argc == 3) {
43509 int _v;
43510 {
43511 void *ptr;
43512 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43513 _v = 0;
43514 PyErr_Clear();
43515 } else {
43516 _v = 1;
43517 }
43518 }
43519 if (_v) {
43520 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43521 if (_v) {
43522 {
43523 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43524 }
43525 if (_v) {
43526 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43527 }
43528 }
43529 }
43530 }
43531
43532 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43533 return NULL;
43534 }
43535
43536
43537 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43538 PyObject *resultobj;
43539 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43540 wxWindow *arg2 = (wxWindow *) 0 ;
43541 wxGBSpan result;
43542 PyObject * obj0 = 0 ;
43543 PyObject * obj1 = 0 ;
43544
43545 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43547 if (SWIG_arg_fail(1)) SWIG_fail;
43548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43549 if (SWIG_arg_fail(2)) SWIG_fail;
43550 {
43551 PyThreadState* __tstate = wxPyBeginAllowThreads();
43552 result = (arg1)->GetItemSpan(arg2);
43553
43554 wxPyEndAllowThreads(__tstate);
43555 if (PyErr_Occurred()) SWIG_fail;
43556 }
43557 {
43558 wxGBSpan * resultptr;
43559 resultptr = new wxGBSpan((wxGBSpan &)(result));
43560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43561 }
43562 return resultobj;
43563 fail:
43564 return NULL;
43565 }
43566
43567
43568 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43569 PyObject *resultobj;
43570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43571 wxSizer *arg2 = (wxSizer *) 0 ;
43572 wxGBSpan result;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575
43576 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43578 if (SWIG_arg_fail(1)) SWIG_fail;
43579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43580 if (SWIG_arg_fail(2)) SWIG_fail;
43581 {
43582 PyThreadState* __tstate = wxPyBeginAllowThreads();
43583 result = (arg1)->GetItemSpan(arg2);
43584
43585 wxPyEndAllowThreads(__tstate);
43586 if (PyErr_Occurred()) SWIG_fail;
43587 }
43588 {
43589 wxGBSpan * resultptr;
43590 resultptr = new wxGBSpan((wxGBSpan &)(result));
43591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43592 }
43593 return resultobj;
43594 fail:
43595 return NULL;
43596 }
43597
43598
43599 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43600 PyObject *resultobj;
43601 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43602 size_t arg2 ;
43603 wxGBSpan result;
43604 PyObject * obj0 = 0 ;
43605 PyObject * obj1 = 0 ;
43606
43607 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43609 if (SWIG_arg_fail(1)) SWIG_fail;
43610 {
43611 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43612 if (SWIG_arg_fail(2)) SWIG_fail;
43613 }
43614 {
43615 PyThreadState* __tstate = wxPyBeginAllowThreads();
43616 result = (arg1)->GetItemSpan(arg2);
43617
43618 wxPyEndAllowThreads(__tstate);
43619 if (PyErr_Occurred()) SWIG_fail;
43620 }
43621 {
43622 wxGBSpan * resultptr;
43623 resultptr = new wxGBSpan((wxGBSpan &)(result));
43624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43625 }
43626 return resultobj;
43627 fail:
43628 return NULL;
43629 }
43630
43631
43632 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43633 int argc;
43634 PyObject *argv[3];
43635 int ii;
43636
43637 argc = PyObject_Length(args);
43638 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43639 argv[ii] = PyTuple_GetItem(args,ii);
43640 }
43641 if (argc == 2) {
43642 int _v;
43643 {
43644 void *ptr;
43645 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43646 _v = 0;
43647 PyErr_Clear();
43648 } else {
43649 _v = 1;
43650 }
43651 }
43652 if (_v) {
43653 {
43654 void *ptr;
43655 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43656 _v = 0;
43657 PyErr_Clear();
43658 } else {
43659 _v = 1;
43660 }
43661 }
43662 if (_v) {
43663 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43664 }
43665 }
43666 }
43667 if (argc == 2) {
43668 int _v;
43669 {
43670 void *ptr;
43671 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43672 _v = 0;
43673 PyErr_Clear();
43674 } else {
43675 _v = 1;
43676 }
43677 }
43678 if (_v) {
43679 {
43680 void *ptr;
43681 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43682 _v = 0;
43683 PyErr_Clear();
43684 } else {
43685 _v = 1;
43686 }
43687 }
43688 if (_v) {
43689 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43690 }
43691 }
43692 }
43693 if (argc == 2) {
43694 int _v;
43695 {
43696 void *ptr;
43697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43698 _v = 0;
43699 PyErr_Clear();
43700 } else {
43701 _v = 1;
43702 }
43703 }
43704 if (_v) {
43705 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43706 if (_v) {
43707 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43708 }
43709 }
43710 }
43711
43712 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43713 return NULL;
43714 }
43715
43716
43717 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43718 PyObject *resultobj;
43719 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43720 wxWindow *arg2 = (wxWindow *) 0 ;
43721 wxGBSpan *arg3 = 0 ;
43722 bool result;
43723 wxGBSpan temp3 ;
43724 PyObject * obj0 = 0 ;
43725 PyObject * obj1 = 0 ;
43726 PyObject * obj2 = 0 ;
43727
43728 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43730 if (SWIG_arg_fail(1)) SWIG_fail;
43731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43732 if (SWIG_arg_fail(2)) SWIG_fail;
43733 {
43734 arg3 = &temp3;
43735 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43736 }
43737 {
43738 PyThreadState* __tstate = wxPyBeginAllowThreads();
43739 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43740
43741 wxPyEndAllowThreads(__tstate);
43742 if (PyErr_Occurred()) SWIG_fail;
43743 }
43744 {
43745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43746 }
43747 return resultobj;
43748 fail:
43749 return NULL;
43750 }
43751
43752
43753 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43754 PyObject *resultobj;
43755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43756 wxSizer *arg2 = (wxSizer *) 0 ;
43757 wxGBSpan *arg3 = 0 ;
43758 bool result;
43759 wxGBSpan temp3 ;
43760 PyObject * obj0 = 0 ;
43761 PyObject * obj1 = 0 ;
43762 PyObject * obj2 = 0 ;
43763
43764 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43766 if (SWIG_arg_fail(1)) SWIG_fail;
43767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43768 if (SWIG_arg_fail(2)) SWIG_fail;
43769 {
43770 arg3 = &temp3;
43771 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43772 }
43773 {
43774 PyThreadState* __tstate = wxPyBeginAllowThreads();
43775 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43776
43777 wxPyEndAllowThreads(__tstate);
43778 if (PyErr_Occurred()) SWIG_fail;
43779 }
43780 {
43781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43782 }
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43790 PyObject *resultobj;
43791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43792 size_t arg2 ;
43793 wxGBSpan *arg3 = 0 ;
43794 bool result;
43795 wxGBSpan temp3 ;
43796 PyObject * obj0 = 0 ;
43797 PyObject * obj1 = 0 ;
43798 PyObject * obj2 = 0 ;
43799
43800 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43802 if (SWIG_arg_fail(1)) SWIG_fail;
43803 {
43804 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43805 if (SWIG_arg_fail(2)) SWIG_fail;
43806 }
43807 {
43808 arg3 = &temp3;
43809 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43810 }
43811 {
43812 PyThreadState* __tstate = wxPyBeginAllowThreads();
43813 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43814
43815 wxPyEndAllowThreads(__tstate);
43816 if (PyErr_Occurred()) SWIG_fail;
43817 }
43818 {
43819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43820 }
43821 return resultobj;
43822 fail:
43823 return NULL;
43824 }
43825
43826
43827 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43828 int argc;
43829 PyObject *argv[4];
43830 int ii;
43831
43832 argc = PyObject_Length(args);
43833 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43834 argv[ii] = PyTuple_GetItem(args,ii);
43835 }
43836 if (argc == 3) {
43837 int _v;
43838 {
43839 void *ptr;
43840 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43841 _v = 0;
43842 PyErr_Clear();
43843 } else {
43844 _v = 1;
43845 }
43846 }
43847 if (_v) {
43848 {
43849 void *ptr;
43850 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43851 _v = 0;
43852 PyErr_Clear();
43853 } else {
43854 _v = 1;
43855 }
43856 }
43857 if (_v) {
43858 {
43859 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43860 }
43861 if (_v) {
43862 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43863 }
43864 }
43865 }
43866 }
43867 if (argc == 3) {
43868 int _v;
43869 {
43870 void *ptr;
43871 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43872 _v = 0;
43873 PyErr_Clear();
43874 } else {
43875 _v = 1;
43876 }
43877 }
43878 if (_v) {
43879 {
43880 void *ptr;
43881 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43882 _v = 0;
43883 PyErr_Clear();
43884 } else {
43885 _v = 1;
43886 }
43887 }
43888 if (_v) {
43889 {
43890 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43891 }
43892 if (_v) {
43893 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43894 }
43895 }
43896 }
43897 }
43898 if (argc == 3) {
43899 int _v;
43900 {
43901 void *ptr;
43902 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43903 _v = 0;
43904 PyErr_Clear();
43905 } else {
43906 _v = 1;
43907 }
43908 }
43909 if (_v) {
43910 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43911 if (_v) {
43912 {
43913 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43914 }
43915 if (_v) {
43916 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43917 }
43918 }
43919 }
43920 }
43921
43922 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43923 return NULL;
43924 }
43925
43926
43927 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43928 PyObject *resultobj;
43929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43930 wxWindow *arg2 = (wxWindow *) 0 ;
43931 wxGBSizerItem *result;
43932 PyObject * obj0 = 0 ;
43933 PyObject * obj1 = 0 ;
43934
43935 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43937 if (SWIG_arg_fail(1)) SWIG_fail;
43938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43939 if (SWIG_arg_fail(2)) SWIG_fail;
43940 {
43941 PyThreadState* __tstate = wxPyBeginAllowThreads();
43942 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43943
43944 wxPyEndAllowThreads(__tstate);
43945 if (PyErr_Occurred()) SWIG_fail;
43946 }
43947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43948 return resultobj;
43949 fail:
43950 return NULL;
43951 }
43952
43953
43954 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43955 PyObject *resultobj;
43956 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43957 wxSizer *arg2 = (wxSizer *) 0 ;
43958 wxGBSizerItem *result;
43959 PyObject * obj0 = 0 ;
43960 PyObject * obj1 = 0 ;
43961
43962 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43964 if (SWIG_arg_fail(1)) SWIG_fail;
43965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43966 if (SWIG_arg_fail(2)) SWIG_fail;
43967 {
43968 PyThreadState* __tstate = wxPyBeginAllowThreads();
43969 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43970
43971 wxPyEndAllowThreads(__tstate);
43972 if (PyErr_Occurred()) SWIG_fail;
43973 }
43974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43975 return resultobj;
43976 fail:
43977 return NULL;
43978 }
43979
43980
43981 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43982 int argc;
43983 PyObject *argv[3];
43984 int ii;
43985
43986 argc = PyObject_Length(args);
43987 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43988 argv[ii] = PyTuple_GetItem(args,ii);
43989 }
43990 if (argc == 2) {
43991 int _v;
43992 {
43993 void *ptr;
43994 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43995 _v = 0;
43996 PyErr_Clear();
43997 } else {
43998 _v = 1;
43999 }
44000 }
44001 if (_v) {
44002 {
44003 void *ptr;
44004 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44005 _v = 0;
44006 PyErr_Clear();
44007 } else {
44008 _v = 1;
44009 }
44010 }
44011 if (_v) {
44012 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44013 }
44014 }
44015 }
44016 if (argc == 2) {
44017 int _v;
44018 {
44019 void *ptr;
44020 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44021 _v = 0;
44022 PyErr_Clear();
44023 } else {
44024 _v = 1;
44025 }
44026 }
44027 if (_v) {
44028 {
44029 void *ptr;
44030 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44031 _v = 0;
44032 PyErr_Clear();
44033 } else {
44034 _v = 1;
44035 }
44036 }
44037 if (_v) {
44038 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44039 }
44040 }
44041 }
44042
44043 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44044 return NULL;
44045 }
44046
44047
44048 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44049 PyObject *resultobj;
44050 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44051 wxGBPosition *arg2 = 0 ;
44052 wxGBSizerItem *result;
44053 wxGBPosition temp2 ;
44054 PyObject * obj0 = 0 ;
44055 PyObject * obj1 = 0 ;
44056 char *kwnames[] = {
44057 (char *) "self",(char *) "pos", NULL
44058 };
44059
44060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44062 if (SWIG_arg_fail(1)) SWIG_fail;
44063 {
44064 arg2 = &temp2;
44065 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44066 }
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44070
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44075 return resultobj;
44076 fail:
44077 return NULL;
44078 }
44079
44080
44081 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44082 PyObject *resultobj;
44083 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44084 wxPoint *arg2 = 0 ;
44085 wxGBSizerItem *result;
44086 wxPoint temp2 ;
44087 PyObject * obj0 = 0 ;
44088 PyObject * obj1 = 0 ;
44089 char *kwnames[] = {
44090 (char *) "self",(char *) "pt", NULL
44091 };
44092
44093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44095 if (SWIG_arg_fail(1)) SWIG_fail;
44096 {
44097 arg2 = &temp2;
44098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44099 }
44100 {
44101 PyThreadState* __tstate = wxPyBeginAllowThreads();
44102 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44103
44104 wxPyEndAllowThreads(__tstate);
44105 if (PyErr_Occurred()) SWIG_fail;
44106 }
44107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44108 return resultobj;
44109 fail:
44110 return NULL;
44111 }
44112
44113
44114 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44115 PyObject *resultobj;
44116 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44117 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44118 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44119 bool result;
44120 PyObject * obj0 = 0 ;
44121 PyObject * obj1 = 0 ;
44122 PyObject * obj2 = 0 ;
44123 char *kwnames[] = {
44124 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44125 };
44126
44127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44129 if (SWIG_arg_fail(1)) SWIG_fail;
44130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44131 if (SWIG_arg_fail(2)) SWIG_fail;
44132 if (obj2) {
44133 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44134 if (SWIG_arg_fail(3)) SWIG_fail;
44135 }
44136 {
44137 PyThreadState* __tstate = wxPyBeginAllowThreads();
44138 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44139
44140 wxPyEndAllowThreads(__tstate);
44141 if (PyErr_Occurred()) SWIG_fail;
44142 }
44143 {
44144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44145 }
44146 return resultobj;
44147 fail:
44148 return NULL;
44149 }
44150
44151
44152 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44153 PyObject *resultobj;
44154 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44155 wxGBPosition *arg2 = 0 ;
44156 wxGBSpan *arg3 = 0 ;
44157 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44158 bool result;
44159 wxGBPosition temp2 ;
44160 wxGBSpan temp3 ;
44161 PyObject * obj0 = 0 ;
44162 PyObject * obj1 = 0 ;
44163 PyObject * obj2 = 0 ;
44164 PyObject * obj3 = 0 ;
44165 char *kwnames[] = {
44166 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44167 };
44168
44169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44171 if (SWIG_arg_fail(1)) SWIG_fail;
44172 {
44173 arg2 = &temp2;
44174 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44175 }
44176 {
44177 arg3 = &temp3;
44178 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44179 }
44180 if (obj3) {
44181 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44182 if (SWIG_arg_fail(4)) SWIG_fail;
44183 }
44184 {
44185 PyThreadState* __tstate = wxPyBeginAllowThreads();
44186 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44187
44188 wxPyEndAllowThreads(__tstate);
44189 if (PyErr_Occurred()) SWIG_fail;
44190 }
44191 {
44192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44193 }
44194 return resultobj;
44195 fail:
44196 return NULL;
44197 }
44198
44199
44200 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44201 PyObject *obj;
44202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44203 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44204 Py_INCREF(obj);
44205 return Py_BuildValue((char *)"");
44206 }
44207 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44208 PyObject *resultobj;
44209 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44210 wxRelationship arg2 ;
44211 wxWindow *arg3 = (wxWindow *) 0 ;
44212 wxEdge arg4 ;
44213 int arg5 = (int) 0 ;
44214 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44215 PyObject * obj0 = 0 ;
44216 PyObject * obj1 = 0 ;
44217 PyObject * obj2 = 0 ;
44218 PyObject * obj3 = 0 ;
44219 PyObject * obj4 = 0 ;
44220 PyObject * obj5 = 0 ;
44221 char *kwnames[] = {
44222 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44223 };
44224
44225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44227 if (SWIG_arg_fail(1)) SWIG_fail;
44228 {
44229 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44230 if (SWIG_arg_fail(2)) SWIG_fail;
44231 }
44232 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44233 if (SWIG_arg_fail(3)) SWIG_fail;
44234 {
44235 arg4 = (wxEdge)(SWIG_As_int(obj3));
44236 if (SWIG_arg_fail(4)) SWIG_fail;
44237 }
44238 if (obj4) {
44239 {
44240 arg5 = (int)(SWIG_As_int(obj4));
44241 if (SWIG_arg_fail(5)) SWIG_fail;
44242 }
44243 }
44244 if (obj5) {
44245 {
44246 arg6 = (int)(SWIG_As_int(obj5));
44247 if (SWIG_arg_fail(6)) SWIG_fail;
44248 }
44249 }
44250 {
44251 PyThreadState* __tstate = wxPyBeginAllowThreads();
44252 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44253
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 Py_INCREF(Py_None); resultobj = Py_None;
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44265 PyObject *resultobj;
44266 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44267 wxWindow *arg2 = (wxWindow *) 0 ;
44268 int arg3 = (int) 0 ;
44269 PyObject * obj0 = 0 ;
44270 PyObject * obj1 = 0 ;
44271 PyObject * obj2 = 0 ;
44272 char *kwnames[] = {
44273 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44274 };
44275
44276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44278 if (SWIG_arg_fail(1)) SWIG_fail;
44279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44280 if (SWIG_arg_fail(2)) SWIG_fail;
44281 if (obj2) {
44282 {
44283 arg3 = (int)(SWIG_As_int(obj2));
44284 if (SWIG_arg_fail(3)) SWIG_fail;
44285 }
44286 }
44287 {
44288 PyThreadState* __tstate = wxPyBeginAllowThreads();
44289 (arg1)->LeftOf(arg2,arg3);
44290
44291 wxPyEndAllowThreads(__tstate);
44292 if (PyErr_Occurred()) SWIG_fail;
44293 }
44294 Py_INCREF(Py_None); resultobj = Py_None;
44295 return resultobj;
44296 fail:
44297 return NULL;
44298 }
44299
44300
44301 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44302 PyObject *resultobj;
44303 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44304 wxWindow *arg2 = (wxWindow *) 0 ;
44305 int arg3 = (int) 0 ;
44306 PyObject * obj0 = 0 ;
44307 PyObject * obj1 = 0 ;
44308 PyObject * obj2 = 0 ;
44309 char *kwnames[] = {
44310 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44311 };
44312
44313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44315 if (SWIG_arg_fail(1)) SWIG_fail;
44316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44317 if (SWIG_arg_fail(2)) SWIG_fail;
44318 if (obj2) {
44319 {
44320 arg3 = (int)(SWIG_As_int(obj2));
44321 if (SWIG_arg_fail(3)) SWIG_fail;
44322 }
44323 }
44324 {
44325 PyThreadState* __tstate = wxPyBeginAllowThreads();
44326 (arg1)->RightOf(arg2,arg3);
44327
44328 wxPyEndAllowThreads(__tstate);
44329 if (PyErr_Occurred()) SWIG_fail;
44330 }
44331 Py_INCREF(Py_None); resultobj = Py_None;
44332 return resultobj;
44333 fail:
44334 return NULL;
44335 }
44336
44337
44338 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44339 PyObject *resultobj;
44340 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44341 wxWindow *arg2 = (wxWindow *) 0 ;
44342 int arg3 = (int) 0 ;
44343 PyObject * obj0 = 0 ;
44344 PyObject * obj1 = 0 ;
44345 PyObject * obj2 = 0 ;
44346 char *kwnames[] = {
44347 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44348 };
44349
44350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44352 if (SWIG_arg_fail(1)) SWIG_fail;
44353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44354 if (SWIG_arg_fail(2)) SWIG_fail;
44355 if (obj2) {
44356 {
44357 arg3 = (int)(SWIG_As_int(obj2));
44358 if (SWIG_arg_fail(3)) SWIG_fail;
44359 }
44360 }
44361 {
44362 PyThreadState* __tstate = wxPyBeginAllowThreads();
44363 (arg1)->Above(arg2,arg3);
44364
44365 wxPyEndAllowThreads(__tstate);
44366 if (PyErr_Occurred()) SWIG_fail;
44367 }
44368 Py_INCREF(Py_None); resultobj = Py_None;
44369 return resultobj;
44370 fail:
44371 return NULL;
44372 }
44373
44374
44375 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44376 PyObject *resultobj;
44377 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44378 wxWindow *arg2 = (wxWindow *) 0 ;
44379 int arg3 = (int) 0 ;
44380 PyObject * obj0 = 0 ;
44381 PyObject * obj1 = 0 ;
44382 PyObject * obj2 = 0 ;
44383 char *kwnames[] = {
44384 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44385 };
44386
44387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44389 if (SWIG_arg_fail(1)) SWIG_fail;
44390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44391 if (SWIG_arg_fail(2)) SWIG_fail;
44392 if (obj2) {
44393 {
44394 arg3 = (int)(SWIG_As_int(obj2));
44395 if (SWIG_arg_fail(3)) SWIG_fail;
44396 }
44397 }
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 (arg1)->Below(arg2,arg3);
44401
44402 wxPyEndAllowThreads(__tstate);
44403 if (PyErr_Occurred()) SWIG_fail;
44404 }
44405 Py_INCREF(Py_None); resultobj = Py_None;
44406 return resultobj;
44407 fail:
44408 return NULL;
44409 }
44410
44411
44412 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44413 PyObject *resultobj;
44414 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44415 wxWindow *arg2 = (wxWindow *) 0 ;
44416 wxEdge arg3 ;
44417 int arg4 = (int) 0 ;
44418 PyObject * obj0 = 0 ;
44419 PyObject * obj1 = 0 ;
44420 PyObject * obj2 = 0 ;
44421 PyObject * obj3 = 0 ;
44422 char *kwnames[] = {
44423 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44424 };
44425
44426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44428 if (SWIG_arg_fail(1)) SWIG_fail;
44429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44430 if (SWIG_arg_fail(2)) SWIG_fail;
44431 {
44432 arg3 = (wxEdge)(SWIG_As_int(obj2));
44433 if (SWIG_arg_fail(3)) SWIG_fail;
44434 }
44435 if (obj3) {
44436 {
44437 arg4 = (int)(SWIG_As_int(obj3));
44438 if (SWIG_arg_fail(4)) SWIG_fail;
44439 }
44440 }
44441 {
44442 PyThreadState* __tstate = wxPyBeginAllowThreads();
44443 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44444
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 Py_INCREF(Py_None); resultobj = Py_None;
44449 return resultobj;
44450 fail:
44451 return NULL;
44452 }
44453
44454
44455 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44456 PyObject *resultobj;
44457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44458 wxWindow *arg2 = (wxWindow *) 0 ;
44459 wxEdge arg3 ;
44460 int arg4 ;
44461 PyObject * obj0 = 0 ;
44462 PyObject * obj1 = 0 ;
44463 PyObject * obj2 = 0 ;
44464 PyObject * obj3 = 0 ;
44465 char *kwnames[] = {
44466 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44467 };
44468
44469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44471 if (SWIG_arg_fail(1)) SWIG_fail;
44472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44473 if (SWIG_arg_fail(2)) SWIG_fail;
44474 {
44475 arg3 = (wxEdge)(SWIG_As_int(obj2));
44476 if (SWIG_arg_fail(3)) SWIG_fail;
44477 }
44478 {
44479 arg4 = (int)(SWIG_As_int(obj3));
44480 if (SWIG_arg_fail(4)) SWIG_fail;
44481 }
44482 {
44483 PyThreadState* __tstate = wxPyBeginAllowThreads();
44484 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44485
44486 wxPyEndAllowThreads(__tstate);
44487 if (PyErr_Occurred()) SWIG_fail;
44488 }
44489 Py_INCREF(Py_None); resultobj = Py_None;
44490 return resultobj;
44491 fail:
44492 return NULL;
44493 }
44494
44495
44496 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44497 PyObject *resultobj;
44498 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44499 int arg2 ;
44500 PyObject * obj0 = 0 ;
44501 PyObject * obj1 = 0 ;
44502 char *kwnames[] = {
44503 (char *) "self",(char *) "val", NULL
44504 };
44505
44506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44508 if (SWIG_arg_fail(1)) SWIG_fail;
44509 {
44510 arg2 = (int)(SWIG_As_int(obj1));
44511 if (SWIG_arg_fail(2)) SWIG_fail;
44512 }
44513 {
44514 PyThreadState* __tstate = wxPyBeginAllowThreads();
44515 (arg1)->Absolute(arg2);
44516
44517 wxPyEndAllowThreads(__tstate);
44518 if (PyErr_Occurred()) SWIG_fail;
44519 }
44520 Py_INCREF(Py_None); resultobj = Py_None;
44521 return resultobj;
44522 fail:
44523 return NULL;
44524 }
44525
44526
44527 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44528 PyObject *resultobj;
44529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44530 PyObject * obj0 = 0 ;
44531 char *kwnames[] = {
44532 (char *) "self", NULL
44533 };
44534
44535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44537 if (SWIG_arg_fail(1)) SWIG_fail;
44538 {
44539 PyThreadState* __tstate = wxPyBeginAllowThreads();
44540 (arg1)->Unconstrained();
44541
44542 wxPyEndAllowThreads(__tstate);
44543 if (PyErr_Occurred()) SWIG_fail;
44544 }
44545 Py_INCREF(Py_None); resultobj = Py_None;
44546 return resultobj;
44547 fail:
44548 return NULL;
44549 }
44550
44551
44552 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44553 PyObject *resultobj;
44554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44555 PyObject * obj0 = 0 ;
44556 char *kwnames[] = {
44557 (char *) "self", NULL
44558 };
44559
44560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44562 if (SWIG_arg_fail(1)) SWIG_fail;
44563 {
44564 PyThreadState* __tstate = wxPyBeginAllowThreads();
44565 (arg1)->AsIs();
44566
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 Py_INCREF(Py_None); resultobj = Py_None;
44571 return resultobj;
44572 fail:
44573 return NULL;
44574 }
44575
44576
44577 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44578 PyObject *resultobj;
44579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44580 wxWindow *result;
44581 PyObject * obj0 = 0 ;
44582 char *kwnames[] = {
44583 (char *) "self", NULL
44584 };
44585
44586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44588 if (SWIG_arg_fail(1)) SWIG_fail;
44589 {
44590 PyThreadState* __tstate = wxPyBeginAllowThreads();
44591 result = (wxWindow *)(arg1)->GetOtherWindow();
44592
44593 wxPyEndAllowThreads(__tstate);
44594 if (PyErr_Occurred()) SWIG_fail;
44595 }
44596 {
44597 resultobj = wxPyMake_wxObject(result, 0);
44598 }
44599 return resultobj;
44600 fail:
44601 return NULL;
44602 }
44603
44604
44605 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44606 PyObject *resultobj;
44607 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44608 wxEdge result;
44609 PyObject * obj0 = 0 ;
44610 char *kwnames[] = {
44611 (char *) "self", NULL
44612 };
44613
44614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44616 if (SWIG_arg_fail(1)) SWIG_fail;
44617 {
44618 PyThreadState* __tstate = wxPyBeginAllowThreads();
44619 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44620
44621 wxPyEndAllowThreads(__tstate);
44622 if (PyErr_Occurred()) SWIG_fail;
44623 }
44624 resultobj = SWIG_From_int((result));
44625 return resultobj;
44626 fail:
44627 return NULL;
44628 }
44629
44630
44631 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44632 PyObject *resultobj;
44633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44634 wxEdge arg2 ;
44635 PyObject * obj0 = 0 ;
44636 PyObject * obj1 = 0 ;
44637 char *kwnames[] = {
44638 (char *) "self",(char *) "which", NULL
44639 };
44640
44641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44643 if (SWIG_arg_fail(1)) SWIG_fail;
44644 {
44645 arg2 = (wxEdge)(SWIG_As_int(obj1));
44646 if (SWIG_arg_fail(2)) SWIG_fail;
44647 }
44648 {
44649 PyThreadState* __tstate = wxPyBeginAllowThreads();
44650 (arg1)->SetEdge((wxEdge )arg2);
44651
44652 wxPyEndAllowThreads(__tstate);
44653 if (PyErr_Occurred()) SWIG_fail;
44654 }
44655 Py_INCREF(Py_None); resultobj = Py_None;
44656 return resultobj;
44657 fail:
44658 return NULL;
44659 }
44660
44661
44662 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44663 PyObject *resultobj;
44664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44665 int arg2 ;
44666 PyObject * obj0 = 0 ;
44667 PyObject * obj1 = 0 ;
44668 char *kwnames[] = {
44669 (char *) "self",(char *) "v", NULL
44670 };
44671
44672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44674 if (SWIG_arg_fail(1)) SWIG_fail;
44675 {
44676 arg2 = (int)(SWIG_As_int(obj1));
44677 if (SWIG_arg_fail(2)) SWIG_fail;
44678 }
44679 {
44680 PyThreadState* __tstate = wxPyBeginAllowThreads();
44681 (arg1)->SetValue(arg2);
44682
44683 wxPyEndAllowThreads(__tstate);
44684 if (PyErr_Occurred()) SWIG_fail;
44685 }
44686 Py_INCREF(Py_None); resultobj = Py_None;
44687 return resultobj;
44688 fail:
44689 return NULL;
44690 }
44691
44692
44693 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44694 PyObject *resultobj;
44695 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44696 int result;
44697 PyObject * obj0 = 0 ;
44698 char *kwnames[] = {
44699 (char *) "self", NULL
44700 };
44701
44702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44704 if (SWIG_arg_fail(1)) SWIG_fail;
44705 {
44706 PyThreadState* __tstate = wxPyBeginAllowThreads();
44707 result = (int)(arg1)->GetMargin();
44708
44709 wxPyEndAllowThreads(__tstate);
44710 if (PyErr_Occurred()) SWIG_fail;
44711 }
44712 {
44713 resultobj = SWIG_From_int((int)(result));
44714 }
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44722 PyObject *resultobj;
44723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44724 int arg2 ;
44725 PyObject * obj0 = 0 ;
44726 PyObject * obj1 = 0 ;
44727 char *kwnames[] = {
44728 (char *) "self",(char *) "m", NULL
44729 };
44730
44731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44733 if (SWIG_arg_fail(1)) SWIG_fail;
44734 {
44735 arg2 = (int)(SWIG_As_int(obj1));
44736 if (SWIG_arg_fail(2)) SWIG_fail;
44737 }
44738 {
44739 PyThreadState* __tstate = wxPyBeginAllowThreads();
44740 (arg1)->SetMargin(arg2);
44741
44742 wxPyEndAllowThreads(__tstate);
44743 if (PyErr_Occurred()) SWIG_fail;
44744 }
44745 Py_INCREF(Py_None); resultobj = Py_None;
44746 return resultobj;
44747 fail:
44748 return NULL;
44749 }
44750
44751
44752 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44753 PyObject *resultobj;
44754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44755 int result;
44756 PyObject * obj0 = 0 ;
44757 char *kwnames[] = {
44758 (char *) "self", NULL
44759 };
44760
44761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44763 if (SWIG_arg_fail(1)) SWIG_fail;
44764 {
44765 PyThreadState* __tstate = wxPyBeginAllowThreads();
44766 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44767
44768 wxPyEndAllowThreads(__tstate);
44769 if (PyErr_Occurred()) SWIG_fail;
44770 }
44771 {
44772 resultobj = SWIG_From_int((int)(result));
44773 }
44774 return resultobj;
44775 fail:
44776 return NULL;
44777 }
44778
44779
44780 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44781 PyObject *resultobj;
44782 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44783 int result;
44784 PyObject * obj0 = 0 ;
44785 char *kwnames[] = {
44786 (char *) "self", NULL
44787 };
44788
44789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44791 if (SWIG_arg_fail(1)) SWIG_fail;
44792 {
44793 PyThreadState* __tstate = wxPyBeginAllowThreads();
44794 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44795
44796 wxPyEndAllowThreads(__tstate);
44797 if (PyErr_Occurred()) SWIG_fail;
44798 }
44799 {
44800 resultobj = SWIG_From_int((int)(result));
44801 }
44802 return resultobj;
44803 fail:
44804 return NULL;
44805 }
44806
44807
44808 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44809 PyObject *resultobj;
44810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44811 int result;
44812 PyObject * obj0 = 0 ;
44813 char *kwnames[] = {
44814 (char *) "self", NULL
44815 };
44816
44817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44819 if (SWIG_arg_fail(1)) SWIG_fail;
44820 {
44821 PyThreadState* __tstate = wxPyBeginAllowThreads();
44822 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44823
44824 wxPyEndAllowThreads(__tstate);
44825 if (PyErr_Occurred()) SWIG_fail;
44826 }
44827 {
44828 resultobj = SWIG_From_int((int)(result));
44829 }
44830 return resultobj;
44831 fail:
44832 return NULL;
44833 }
44834
44835
44836 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44837 PyObject *resultobj;
44838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44839 bool result;
44840 PyObject * obj0 = 0 ;
44841 char *kwnames[] = {
44842 (char *) "self", NULL
44843 };
44844
44845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44847 if (SWIG_arg_fail(1)) SWIG_fail;
44848 {
44849 PyThreadState* __tstate = wxPyBeginAllowThreads();
44850 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44851
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 {
44856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44857 }
44858 return resultobj;
44859 fail:
44860 return NULL;
44861 }
44862
44863
44864 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44865 PyObject *resultobj;
44866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44867 bool arg2 ;
44868 PyObject * obj0 = 0 ;
44869 PyObject * obj1 = 0 ;
44870 char *kwnames[] = {
44871 (char *) "self",(char *) "d", NULL
44872 };
44873
44874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44876 if (SWIG_arg_fail(1)) SWIG_fail;
44877 {
44878 arg2 = (bool)(SWIG_As_bool(obj1));
44879 if (SWIG_arg_fail(2)) SWIG_fail;
44880 }
44881 {
44882 PyThreadState* __tstate = wxPyBeginAllowThreads();
44883 (arg1)->SetDone(arg2);
44884
44885 wxPyEndAllowThreads(__tstate);
44886 if (PyErr_Occurred()) SWIG_fail;
44887 }
44888 Py_INCREF(Py_None); resultobj = Py_None;
44889 return resultobj;
44890 fail:
44891 return NULL;
44892 }
44893
44894
44895 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44896 PyObject *resultobj;
44897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44898 wxRelationship result;
44899 PyObject * obj0 = 0 ;
44900 char *kwnames[] = {
44901 (char *) "self", NULL
44902 };
44903
44904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44906 if (SWIG_arg_fail(1)) SWIG_fail;
44907 {
44908 PyThreadState* __tstate = wxPyBeginAllowThreads();
44909 result = (wxRelationship)(arg1)->GetRelationship();
44910
44911 wxPyEndAllowThreads(__tstate);
44912 if (PyErr_Occurred()) SWIG_fail;
44913 }
44914 resultobj = SWIG_From_int((result));
44915 return resultobj;
44916 fail:
44917 return NULL;
44918 }
44919
44920
44921 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44922 PyObject *resultobj;
44923 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44924 wxRelationship arg2 ;
44925 PyObject * obj0 = 0 ;
44926 PyObject * obj1 = 0 ;
44927 char *kwnames[] = {
44928 (char *) "self",(char *) "r", NULL
44929 };
44930
44931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44933 if (SWIG_arg_fail(1)) SWIG_fail;
44934 {
44935 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44936 if (SWIG_arg_fail(2)) SWIG_fail;
44937 }
44938 {
44939 PyThreadState* __tstate = wxPyBeginAllowThreads();
44940 (arg1)->SetRelationship((wxRelationship )arg2);
44941
44942 wxPyEndAllowThreads(__tstate);
44943 if (PyErr_Occurred()) SWIG_fail;
44944 }
44945 Py_INCREF(Py_None); resultobj = Py_None;
44946 return resultobj;
44947 fail:
44948 return NULL;
44949 }
44950
44951
44952 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44953 PyObject *resultobj;
44954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44955 wxWindow *arg2 = (wxWindow *) 0 ;
44956 bool result;
44957 PyObject * obj0 = 0 ;
44958 PyObject * obj1 = 0 ;
44959 char *kwnames[] = {
44960 (char *) "self",(char *) "otherW", NULL
44961 };
44962
44963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44965 if (SWIG_arg_fail(1)) SWIG_fail;
44966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44967 if (SWIG_arg_fail(2)) SWIG_fail;
44968 {
44969 PyThreadState* __tstate = wxPyBeginAllowThreads();
44970 result = (bool)(arg1)->ResetIfWin(arg2);
44971
44972 wxPyEndAllowThreads(__tstate);
44973 if (PyErr_Occurred()) SWIG_fail;
44974 }
44975 {
44976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44977 }
44978 return resultobj;
44979 fail:
44980 return NULL;
44981 }
44982
44983
44984 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44985 PyObject *resultobj;
44986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44987 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44988 wxWindow *arg3 = (wxWindow *) 0 ;
44989 bool result;
44990 PyObject * obj0 = 0 ;
44991 PyObject * obj1 = 0 ;
44992 PyObject * obj2 = 0 ;
44993 char *kwnames[] = {
44994 (char *) "self",(char *) "constraints",(char *) "win", NULL
44995 };
44996
44997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44999 if (SWIG_arg_fail(1)) SWIG_fail;
45000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45001 if (SWIG_arg_fail(2)) SWIG_fail;
45002 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45003 if (SWIG_arg_fail(3)) SWIG_fail;
45004 {
45005 PyThreadState* __tstate = wxPyBeginAllowThreads();
45006 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45007
45008 wxPyEndAllowThreads(__tstate);
45009 if (PyErr_Occurred()) SWIG_fail;
45010 }
45011 {
45012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45013 }
45014 return resultobj;
45015 fail:
45016 return NULL;
45017 }
45018
45019
45020 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45021 PyObject *resultobj;
45022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45023 wxEdge arg2 ;
45024 wxWindow *arg3 = (wxWindow *) 0 ;
45025 wxWindow *arg4 = (wxWindow *) 0 ;
45026 int result;
45027 PyObject * obj0 = 0 ;
45028 PyObject * obj1 = 0 ;
45029 PyObject * obj2 = 0 ;
45030 PyObject * obj3 = 0 ;
45031 char *kwnames[] = {
45032 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45033 };
45034
45035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45037 if (SWIG_arg_fail(1)) SWIG_fail;
45038 {
45039 arg2 = (wxEdge)(SWIG_As_int(obj1));
45040 if (SWIG_arg_fail(2)) SWIG_fail;
45041 }
45042 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45043 if (SWIG_arg_fail(3)) SWIG_fail;
45044 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45045 if (SWIG_arg_fail(4)) SWIG_fail;
45046 {
45047 PyThreadState* __tstate = wxPyBeginAllowThreads();
45048 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45049
45050 wxPyEndAllowThreads(__tstate);
45051 if (PyErr_Occurred()) SWIG_fail;
45052 }
45053 {
45054 resultobj = SWIG_From_int((int)(result));
45055 }
45056 return resultobj;
45057 fail:
45058 return NULL;
45059 }
45060
45061
45062 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45063 PyObject *obj;
45064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45065 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45066 Py_INCREF(obj);
45067 return Py_BuildValue((char *)"");
45068 }
45069 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45070 PyObject *resultobj;
45071 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45072 wxIndividualLayoutConstraint *result;
45073 PyObject * obj0 = 0 ;
45074 char *kwnames[] = {
45075 (char *) "self", NULL
45076 };
45077
45078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45080 if (SWIG_arg_fail(1)) SWIG_fail;
45081 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45082
45083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45084 return resultobj;
45085 fail:
45086 return NULL;
45087 }
45088
45089
45090 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45091 PyObject *resultobj;
45092 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45093 wxIndividualLayoutConstraint *result;
45094 PyObject * obj0 = 0 ;
45095 char *kwnames[] = {
45096 (char *) "self", NULL
45097 };
45098
45099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45101 if (SWIG_arg_fail(1)) SWIG_fail;
45102 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45103
45104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45105 return resultobj;
45106 fail:
45107 return NULL;
45108 }
45109
45110
45111 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45112 PyObject *resultobj;
45113 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45114 wxIndividualLayoutConstraint *result;
45115 PyObject * obj0 = 0 ;
45116 char *kwnames[] = {
45117 (char *) "self", NULL
45118 };
45119
45120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45122 if (SWIG_arg_fail(1)) SWIG_fail;
45123 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45124
45125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45126 return resultobj;
45127 fail:
45128 return NULL;
45129 }
45130
45131
45132 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45133 PyObject *resultobj;
45134 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45135 wxIndividualLayoutConstraint *result;
45136 PyObject * obj0 = 0 ;
45137 char *kwnames[] = {
45138 (char *) "self", NULL
45139 };
45140
45141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45143 if (SWIG_arg_fail(1)) SWIG_fail;
45144 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45145
45146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45147 return resultobj;
45148 fail:
45149 return NULL;
45150 }
45151
45152
45153 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45154 PyObject *resultobj;
45155 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45156 wxIndividualLayoutConstraint *result;
45157 PyObject * obj0 = 0 ;
45158 char *kwnames[] = {
45159 (char *) "self", NULL
45160 };
45161
45162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45164 if (SWIG_arg_fail(1)) SWIG_fail;
45165 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45166
45167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45168 return resultobj;
45169 fail:
45170 return NULL;
45171 }
45172
45173
45174 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45175 PyObject *resultobj;
45176 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45177 wxIndividualLayoutConstraint *result;
45178 PyObject * obj0 = 0 ;
45179 char *kwnames[] = {
45180 (char *) "self", NULL
45181 };
45182
45183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45185 if (SWIG_arg_fail(1)) SWIG_fail;
45186 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45187
45188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45196 PyObject *resultobj;
45197 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45198 wxIndividualLayoutConstraint *result;
45199 PyObject * obj0 = 0 ;
45200 char *kwnames[] = {
45201 (char *) "self", NULL
45202 };
45203
45204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45206 if (SWIG_arg_fail(1)) SWIG_fail;
45207 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45208
45209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45210 return resultobj;
45211 fail:
45212 return NULL;
45213 }
45214
45215
45216 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45217 PyObject *resultobj;
45218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45219 wxIndividualLayoutConstraint *result;
45220 PyObject * obj0 = 0 ;
45221 char *kwnames[] = {
45222 (char *) "self", NULL
45223 };
45224
45225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45227 if (SWIG_arg_fail(1)) SWIG_fail;
45228 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45229
45230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45231 return resultobj;
45232 fail:
45233 return NULL;
45234 }
45235
45236
45237 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45238 PyObject *resultobj;
45239 wxLayoutConstraints *result;
45240 char *kwnames[] = {
45241 NULL
45242 };
45243
45244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45248
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45253 return resultobj;
45254 fail:
45255 return NULL;
45256 }
45257
45258
45259 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45260 PyObject *resultobj;
45261 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45262 wxWindow *arg2 = (wxWindow *) 0 ;
45263 int *arg3 = (int *) 0 ;
45264 bool result;
45265 int temp3 ;
45266 int res3 = 0 ;
45267 PyObject * obj0 = 0 ;
45268 PyObject * obj1 = 0 ;
45269 char *kwnames[] = {
45270 (char *) "self",(char *) "win", NULL
45271 };
45272
45273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45276 if (SWIG_arg_fail(1)) SWIG_fail;
45277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45278 if (SWIG_arg_fail(2)) SWIG_fail;
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45282
45283 wxPyEndAllowThreads(__tstate);
45284 if (PyErr_Occurred()) SWIG_fail;
45285 }
45286 {
45287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45288 }
45289 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45290 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45291 return resultobj;
45292 fail:
45293 return NULL;
45294 }
45295
45296
45297 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45298 PyObject *resultobj;
45299 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45300 bool result;
45301 PyObject * obj0 = 0 ;
45302 char *kwnames[] = {
45303 (char *) "self", NULL
45304 };
45305
45306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45308 if (SWIG_arg_fail(1)) SWIG_fail;
45309 {
45310 PyThreadState* __tstate = wxPyBeginAllowThreads();
45311 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45312
45313 wxPyEndAllowThreads(__tstate);
45314 if (PyErr_Occurred()) SWIG_fail;
45315 }
45316 {
45317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45318 }
45319 return resultobj;
45320 fail:
45321 return NULL;
45322 }
45323
45324
45325 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45326 PyObject *obj;
45327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45328 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45329 Py_INCREF(obj);
45330 return Py_BuildValue((char *)"");
45331 }
45332 static PyMethodDef SwigMethods[] = {
45333 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45334 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45335 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45338 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45359 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45372 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45387 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45441 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45469 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45488 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45490 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45498 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45499 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45511 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45523 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45527 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45533 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45543 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45553 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45560 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45640 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45646 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45648 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45650 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45656 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45658 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45660 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45662 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45664 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45678 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45696 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45699 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45702 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45714 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45719 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45725 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45731 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45794 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45801 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45837 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45847 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45853 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45855 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45857 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45860 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45864 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45870 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45872 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45877 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45885 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45889 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45892 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45894 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45898 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45915 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45917 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45920 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45922 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45926 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45930 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45941 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45944 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45947 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45963 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45972 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46017 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46037 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46044 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46048 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46058 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46230 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46272 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46287 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46290 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46345 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46372 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46424 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46443 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46444 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46481 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46511 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46514 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46518 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46521 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46531 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46543 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46555 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46565 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46575 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46589 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46596 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46597 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46598 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46599 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46600 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46605 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46632 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46644 { NULL, NULL, 0, NULL }
46645 };
46646
46647
46648 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46649
46650 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46651 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46652 }
46653 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46654 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46655 }
46656 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46657 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46658 }
46659 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46660 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46661 }
46662 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46663 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46664 }
46665 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46666 return (void *)((wxSizer *) ((wxGridSizer *) x));
46667 }
46668 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46669 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46670 }
46671 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46672 return (void *)((wxSizer *) ((wxPySizer *) x));
46673 }
46674 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46675 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46676 }
46677 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46678 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46679 }
46680 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46681 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46682 }
46683 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46684 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46685 }
46686 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46687 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46688 }
46689 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46690 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46691 }
46692 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46693 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46694 }
46695 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46696 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46697 }
46698 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46699 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46700 }
46701 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46702 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46703 }
46704 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46705 return (void *)((wxEvent *) ((wxPyEvent *) x));
46706 }
46707 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46708 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46709 }
46710 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46711 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46712 }
46713 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46714 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46715 }
46716 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46717 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46718 }
46719 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46720 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46721 }
46722 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46723 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46724 }
46725 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46726 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46727 }
46728 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46729 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46730 }
46731 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46732 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46733 }
46734 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46735 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46736 }
46737 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46738 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46739 }
46740 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46741 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46742 }
46743 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46744 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46745 }
46746 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46747 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46748 }
46749 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46750 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46751 }
46752 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46753 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46754 }
46755 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46756 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46757 }
46758 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46759 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46760 }
46761 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46762 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46763 }
46764 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46765 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46766 }
46767 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46768 return (void *)((wxEvent *) ((wxShowEvent *) x));
46769 }
46770 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46771 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46772 }
46773 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46774 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46775 }
46776 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46777 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46778 }
46779 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46780 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46781 }
46782 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46783 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46784 }
46785 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46786 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46787 }
46788 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46789 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46790 }
46791 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46792 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46793 }
46794 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46795 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46796 }
46797 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46798 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46799 }
46800 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46801 return (void *)((wxControl *) ((wxControlWithItems *) x));
46802 }
46803 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46804 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46805 }
46806 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46807 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46808 }
46809 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46810 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46811 }
46812 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46813 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46814 }
46815 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46816 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46817 }
46818 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46819 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46820 }
46821 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46822 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46823 }
46824 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46825 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46826 }
46827 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46828 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46829 }
46830 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46831 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46832 }
46833 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46834 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46835 }
46836 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46837 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46838 }
46839 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46840 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46841 }
46842 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46843 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46844 }
46845 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46846 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46847 }
46848 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46849 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46850 }
46851 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46852 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46853 }
46854 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46855 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46856 }
46857 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46858 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46859 }
46860 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46861 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46862 }
46863 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46864 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46865 }
46866 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46867 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46868 }
46869 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46870 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46871 }
46872 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46873 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46874 }
46875 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46876 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46877 }
46878 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46879 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46880 }
46881 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46882 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46883 }
46884 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46885 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46886 }
46887 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46888 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46889 }
46890 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46891 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46892 }
46893 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46894 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46895 }
46896 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46897 return (void *)((wxObject *) ((wxSizerItem *) x));
46898 }
46899 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46900 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46901 }
46902 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46903 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46904 }
46905 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46906 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46907 }
46908 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46909 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46910 }
46911 static void *_p_wxSizerTo_p_wxObject(void *x) {
46912 return (void *)((wxObject *) ((wxSizer *) x));
46913 }
46914 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46915 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46916 }
46917 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46918 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46919 }
46920 static void *_p_wxEventTo_p_wxObject(void *x) {
46921 return (void *)((wxObject *) ((wxEvent *) x));
46922 }
46923 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46924 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46925 }
46926 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46927 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46928 }
46929 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46930 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46931 }
46932 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46933 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46934 }
46935 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46936 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46937 }
46938 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46939 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46940 }
46941 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46942 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46943 }
46944 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46945 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46946 }
46947 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46948 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46949 }
46950 static void *_p_wxControlTo_p_wxObject(void *x) {
46951 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46952 }
46953 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46954 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46955 }
46956 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46957 return (void *)((wxObject *) ((wxFSFile *) x));
46958 }
46959 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46960 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46961 }
46962 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46963 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46964 }
46965 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46966 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46967 }
46968 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46969 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46970 }
46971 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46972 return (void *)((wxObject *) ((wxMenuItem *) x));
46973 }
46974 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46975 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46976 }
46977 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46978 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46979 }
46980 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46982 }
46983 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46984 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46985 }
46986 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46987 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46988 }
46989 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46990 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46991 }
46992 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46993 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46994 }
46995 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46996 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46997 }
46998 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46999 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47000 }
47001 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47002 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47003 }
47004 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47005 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47006 }
47007 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47008 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47009 }
47010 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47011 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47012 }
47013 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47014 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47015 }
47016 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47017 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47018 }
47019 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47020 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47021 }
47022 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47023 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47024 }
47025 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47026 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47027 }
47028 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47029 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47030 }
47031 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47032 return (void *)((wxObject *) ((wxImageHandler *) x));
47033 }
47034 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47035 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47036 }
47037 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47038 return (void *)((wxObject *) ((wxEvtHandler *) x));
47039 }
47040 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47041 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47042 }
47043 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47044 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47045 }
47046 static void *_p_wxImageTo_p_wxObject(void *x) {
47047 return (void *)((wxObject *) ((wxImage *) x));
47048 }
47049 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47050 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47051 }
47052 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47053 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47054 }
47055 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47056 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47057 }
47058 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47059 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47060 }
47061 static void *_p_wxWindowTo_p_wxObject(void *x) {
47062 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47063 }
47064 static void *_p_wxMenuTo_p_wxObject(void *x) {
47065 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47066 }
47067 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47068 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47069 }
47070 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47071 return (void *)((wxObject *) ((wxFileSystem *) x));
47072 }
47073 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47074 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47075 }
47076 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47077 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47078 }
47079 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47080 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47081 }
47082 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47083 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47084 }
47085 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47086 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47087 }
47088 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47089 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47090 }
47091 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47092 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47093 }
47094 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47095 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47096 }
47097 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47098 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47099 }
47100 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47101 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47102 }
47103 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47105 }
47106 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47107 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47108 }
47109 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47110 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47111 }
47112 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47113 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47114 }
47115 static void *_p_wxControlTo_p_wxWindow(void *x) {
47116 return (void *)((wxWindow *) ((wxControl *) x));
47117 }
47118 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47119 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47120 }
47121 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47122 return (void *)((wxWindow *) ((wxMenuBar *) x));
47123 }
47124 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47125 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47126 }
47127 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47128 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47129 }
47130 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47131 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47132 }
47133 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47134 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47135 }
47136 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47137 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47138 }
47139 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47140 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47141 }
47142 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47143 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47144 }
47145 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47146 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47147 }
47148 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47149 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47150 }
47151 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47152 return (void *)((wxValidator *) ((wxPyValidator *) x));
47153 }
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 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}};
47281 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}};
47282
47283 static swig_type_info *swig_types_initial[] = {
47284 _swigt__p_wxLayoutConstraints,
47285 _swigt__p_wxRealPoint,
47286 _swigt__p_wxSizerItem,
47287 _swigt__p_wxGBSizerItem,
47288 _swigt__p_wxScrollEvent,
47289 _swigt__p_wxEventLoop,
47290 _swigt__p_wxIndividualLayoutConstraint,
47291 _swigt__p_wxSizer,
47292 _swigt__p_wxBoxSizer,
47293 _swigt__p_wxStaticBoxSizer,
47294 _swigt__p_wxGridBagSizer,
47295 _swigt__p_wxAcceleratorEntry,
47296 _swigt__p_wxUpdateUIEvent,
47297 _swigt__p_wxEvent,
47298 _swigt__p_buffer,
47299 _swigt__p_wxMenu,
47300 _swigt__p_wxGridSizer,
47301 _swigt__p_wxFlexGridSizer,
47302 _swigt__p_wxInitDialogEvent,
47303 _swigt__p_wxItemContainer,
47304 _swigt__p_wxNcPaintEvent,
47305 _swigt__p_wxPaintEvent,
47306 _swigt__p_wxSysColourChangedEvent,
47307 _swigt__p_wxMouseCaptureChangedEvent,
47308 _swigt__p_wxDisplayChangedEvent,
47309 _swigt__p_wxPaletteChangedEvent,
47310 _swigt__p_wxControl,
47311 _swigt__p_wxFont,
47312 _swigt__p_wxMenuBarBase,
47313 _swigt__p_wxSetCursorEvent,
47314 _swigt__p_wxFSFile,
47315 _swigt__p_wxCaret,
47316 _swigt__ptrdiff_t,
47317 _swigt__std__ptrdiff_t,
47318 _swigt__p_wxRegion,
47319 _swigt__p_wxPoint2D,
47320 _swigt__p_int,
47321 _swigt__p_wxSize,
47322 _swigt__p_wxDC,
47323 _swigt__p_wxPySizer,
47324 _swigt__p_wxVisualAttributes,
47325 _swigt__p_wxNotifyEvent,
47326 _swigt__p_wxPyEvent,
47327 _swigt__p_wxPropagationDisabler,
47328 _swigt__p_form_ops_t,
47329 _swigt__p_wxAppTraits,
47330 _swigt__p_wxArrayString,
47331 _swigt__p_wxShowEvent,
47332 _swigt__p_wxToolTip,
47333 _swigt__p_wxMoveEvent,
47334 _swigt__p_wxSizeEvent,
47335 _swigt__p_wxActivateEvent,
47336 _swigt__p_wxIconizeEvent,
47337 _swigt__p_wxMaximizeEvent,
47338 _swigt__p_wxQueryNewPaletteEvent,
47339 _swigt__p_wxWindowCreateEvent,
47340 _swigt__p_wxIdleEvent,
47341 _swigt__p_wxDateEvent,
47342 _swigt__p_wxMenuItem,
47343 _swigt__p_wxStaticBox,
47344 _swigt__p_long,
47345 _swigt__p_wxDuplexMode,
47346 _swigt__p_wxTIFFHandler,
47347 _swigt__p_wxXPMHandler,
47348 _swigt__p_wxPNMHandler,
47349 _swigt__p_wxJPEGHandler,
47350 _swigt__p_wxPCXHandler,
47351 _swigt__p_wxGIFHandler,
47352 _swigt__p_wxPNGHandler,
47353 _swigt__p_wxANIHandler,
47354 _swigt__p_wxMemoryFSHandler,
47355 _swigt__p_wxZipFSHandler,
47356 _swigt__p_wxInternetFSHandler,
47357 _swigt__p_wxPyFileSystemHandler,
47358 _swigt__p_wxEvtHandler,
47359 _swigt__p_wxCURHandler,
47360 _swigt__p_wxICOHandler,
47361 _swigt__p_wxBMPHandler,
47362 _swigt__p_wxImageHandler,
47363 _swigt__p_wxFileSystemHandler,
47364 _swigt__p_wxRect,
47365 _swigt__p_wxButton,
47366 _swigt__p_wxGBSpan,
47367 _swigt__p_wxPropagateOnce,
47368 _swigt__p_wxAcceleratorTable,
47369 _swigt__p_wxStdDialogButtonSizer,
47370 _swigt__p_char,
47371 _swigt__p_wxGBPosition,
47372 _swigt__p_wxImage,
47373 _swigt__p_wxFrame,
47374 _swigt__p_wxScrollWinEvent,
47375 _swigt__p_wxPaperSize,
47376 _swigt__p_wxImageHistogram,
47377 _swigt__p_wxPoint,
47378 _swigt__p_wxCursor,
47379 _swigt__p_wxObject,
47380 _swigt__p_wxInputStream,
47381 _swigt__p_wxOutputStream,
47382 _swigt__p_wxPyInputStream,
47383 _swigt__p_wxDateTime,
47384 _swigt__p_wxKeyEvent,
47385 _swigt__p_wxNavigationKeyEvent,
47386 _swigt__p_wxWindowDestroyEvent,
47387 _swigt__p_unsigned_long,
47388 _swigt__p_wxWindow,
47389 _swigt__p_wxMenuBar,
47390 _swigt__p_wxFileSystem,
47391 _swigt__p_wxBitmap,
47392 _swigt__unsigned_int,
47393 _swigt__p_unsigned_int,
47394 _swigt__p_wxMenuEvent,
47395 _swigt__p_wxContextMenuEvent,
47396 _swigt__p_unsigned_char,
47397 _swigt__p_wxEraseEvent,
47398 _swigt__p_wxMouseEvent,
47399 _swigt__p_wxCloseEvent,
47400 _swigt__p_wxPyApp,
47401 _swigt__p_wxCommandEvent,
47402 _swigt__p_wxPyCommandEvent,
47403 _swigt__p_wxPyDropTarget,
47404 _swigt__p_wxQuantize,
47405 _swigt__p_wxFocusEvent,
47406 _swigt__p_wxChildFocusEvent,
47407 _swigt__p_wxDropFilesEvent,
47408 _swigt__p_wxControlWithItems,
47409 _swigt__p_wxColour,
47410 _swigt__p_wxValidator,
47411 _swigt__p_wxPyValidator,
47412 0
47413 };
47414
47415
47416 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47417
47418 static swig_const_info swig_const_table[] = {
47419 {0, 0, 0, 0.0, 0, 0}};
47420
47421 #ifdef __cplusplus
47422 }
47423 #endif
47424
47425
47426 #ifdef __cplusplus
47427 extern "C" {
47428 #endif
47429
47430 /* Python-specific SWIG API */
47431 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47432 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47433 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47434
47435 /* -----------------------------------------------------------------------------
47436 * global variable support code.
47437 * ----------------------------------------------------------------------------- */
47438
47439 typedef struct swig_globalvar {
47440 char *name; /* Name of global variable */
47441 PyObject *(*get_attr)(); /* Return the current value */
47442 int (*set_attr)(PyObject *); /* Set the value */
47443 struct swig_globalvar *next;
47444 } swig_globalvar;
47445
47446 typedef struct swig_varlinkobject {
47447 PyObject_HEAD
47448 swig_globalvar *vars;
47449 } swig_varlinkobject;
47450
47451 static PyObject *
47452 swig_varlink_repr(swig_varlinkobject *v) {
47453 v = v;
47454 return PyString_FromString("<Swig global variables>");
47455 }
47456
47457 static int
47458 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47459 swig_globalvar *var;
47460 flags = flags;
47461 fprintf(fp,"Swig global variables { ");
47462 for (var = v->vars; var; var=var->next) {
47463 fprintf(fp,"%s", var->name);
47464 if (var->next) fprintf(fp,", ");
47465 }
47466 fprintf(fp," }\n");
47467 return 0;
47468 }
47469
47470 static PyObject *
47471 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47472 swig_globalvar *var = v->vars;
47473 while (var) {
47474 if (strcmp(var->name,n) == 0) {
47475 return (*var->get_attr)();
47476 }
47477 var = var->next;
47478 }
47479 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47480 return NULL;
47481 }
47482
47483 static int
47484 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47485 swig_globalvar *var = v->vars;
47486 while (var) {
47487 if (strcmp(var->name,n) == 0) {
47488 return (*var->set_attr)(p);
47489 }
47490 var = var->next;
47491 }
47492 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47493 return 1;
47494 }
47495
47496 static PyTypeObject varlinktype = {
47497 PyObject_HEAD_INIT(0)
47498 0, /* Number of items in variable part (ob_size) */
47499 (char *)"swigvarlink", /* Type name (tp_name) */
47500 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47501 0, /* Itemsize (tp_itemsize) */
47502 0, /* Deallocator (tp_dealloc) */
47503 (printfunc) swig_varlink_print, /* Print (tp_print) */
47504 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47505 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47506 0, /* tp_compare */
47507 (reprfunc) swig_varlink_repr, /* tp_repr */
47508 0, /* tp_as_number */
47509 0, /* tp_as_sequence */
47510 0, /* tp_as_mapping */
47511 0, /* tp_hash */
47512 0, /* tp_call */
47513 0, /* tp_str */
47514 0, /* tp_getattro */
47515 0, /* tp_setattro */
47516 0, /* tp_as_buffer */
47517 0, /* tp_flags */
47518 0, /* tp_doc */
47519 #if PY_VERSION_HEX >= 0x02000000
47520 0, /* tp_traverse */
47521 0, /* tp_clear */
47522 #endif
47523 #if PY_VERSION_HEX >= 0x02010000
47524 0, /* tp_richcompare */
47525 0, /* tp_weaklistoffset */
47526 #endif
47527 #if PY_VERSION_HEX >= 0x02020000
47528 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47529 #endif
47530 #if PY_VERSION_HEX >= 0x02030000
47531 0, /* tp_del */
47532 #endif
47533 #ifdef COUNT_ALLOCS
47534 0,0,0,0 /* tp_alloc -> tp_next */
47535 #endif
47536 };
47537
47538 /* Create a variable linking object for use later */
47539 static PyObject *
47540 SWIG_Python_newvarlink(void) {
47541 swig_varlinkobject *result = 0;
47542 result = PyMem_NEW(swig_varlinkobject,1);
47543 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47544 result->ob_type = &varlinktype;
47545 result->vars = 0;
47546 result->ob_refcnt = 0;
47547 Py_XINCREF((PyObject *) result);
47548 return ((PyObject*) result);
47549 }
47550
47551 static void
47552 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47553 swig_varlinkobject *v;
47554 swig_globalvar *gv;
47555 v= (swig_varlinkobject *) p;
47556 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47557 gv->name = (char *) malloc(strlen(name)+1);
47558 strcpy(gv->name,name);
47559 gv->get_attr = get_attr;
47560 gv->set_attr = set_attr;
47561 gv->next = v->vars;
47562 v->vars = gv;
47563 }
47564
47565 /* -----------------------------------------------------------------------------
47566 * constants/methods manipulation
47567 * ----------------------------------------------------------------------------- */
47568
47569 /* Install Constants */
47570 static void
47571 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47572 PyObject *obj = 0;
47573 size_t i;
47574 for (i = 0; constants[i].type; i++) {
47575 switch(constants[i].type) {
47576 case SWIG_PY_INT:
47577 obj = PyInt_FromLong(constants[i].lvalue);
47578 break;
47579 case SWIG_PY_FLOAT:
47580 obj = PyFloat_FromDouble(constants[i].dvalue);
47581 break;
47582 case SWIG_PY_STRING:
47583 if (constants[i].pvalue) {
47584 obj = PyString_FromString((char *) constants[i].pvalue);
47585 } else {
47586 Py_INCREF(Py_None);
47587 obj = Py_None;
47588 }
47589 break;
47590 case SWIG_PY_POINTER:
47591 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47592 break;
47593 case SWIG_PY_BINARY:
47594 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47595 break;
47596 default:
47597 obj = 0;
47598 break;
47599 }
47600 if (obj) {
47601 PyDict_SetItemString(d,constants[i].name,obj);
47602 Py_DECREF(obj);
47603 }
47604 }
47605 }
47606
47607 /* -----------------------------------------------------------------------------*/
47608 /* Fix SwigMethods to carry the callback ptrs when needed */
47609 /* -----------------------------------------------------------------------------*/
47610
47611 static void
47612 SWIG_Python_FixMethods(PyMethodDef *methods,
47613 swig_const_info *const_table,
47614 swig_type_info **types,
47615 swig_type_info **types_initial) {
47616 size_t i;
47617 for (i = 0; methods[i].ml_name; ++i) {
47618 char *c = methods[i].ml_doc;
47619 if (c && (c = strstr(c, "swig_ptr: "))) {
47620 int j;
47621 swig_const_info *ci = 0;
47622 char *name = c + 10;
47623 for (j = 0; const_table[j].type; j++) {
47624 if (strncmp(const_table[j].name, name,
47625 strlen(const_table[j].name)) == 0) {
47626 ci = &(const_table[j]);
47627 break;
47628 }
47629 }
47630 if (ci) {
47631 size_t shift = (ci->ptype) - types;
47632 swig_type_info *ty = types_initial[shift];
47633 size_t ldoc = (c - methods[i].ml_doc);
47634 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47635 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47636 char *buff = ndoc;
47637 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47638 strncpy(buff, methods[i].ml_doc, ldoc);
47639 buff += ldoc;
47640 strncpy(buff, "swig_ptr: ", 10);
47641 buff += 10;
47642 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47643 methods[i].ml_doc = ndoc;
47644 }
47645 }
47646 }
47647 }
47648
47649 /* -----------------------------------------------------------------------------*
47650 * Initialize type list
47651 * -----------------------------------------------------------------------------*/
47652
47653 #if PY_MAJOR_VERSION < 2
47654 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47655 is copied out of Python/modsupport.c in python version 2.3.4 */
47656 static int
47657 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47658 {
47659 PyObject *dict;
47660 if (!PyModule_Check(m)) {
47661 PyErr_SetString(PyExc_TypeError,
47662 "PyModule_AddObject() needs module as first arg");
47663 return -1;
47664 }
47665 if (!o) {
47666 PyErr_SetString(PyExc_TypeError,
47667 "PyModule_AddObject() needs non-NULL value");
47668 return -1;
47669 }
47670
47671 dict = PyModule_GetDict(m);
47672 if (dict == NULL) {
47673 /* Internal error -- modules must have a dict! */
47674 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47675 PyModule_GetName(m));
47676 return -1;
47677 }
47678 if (PyDict_SetItemString(dict, name, o))
47679 return -1;
47680 Py_DECREF(o);
47681 return 0;
47682 }
47683 #endif
47684
47685 static swig_type_info **
47686 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47687 static PyMethodDef swig_empty_runtime_method_table[] = {
47688 {
47689 NULL, NULL, 0, NULL
47690 }
47691 };/* Sentinel */
47692
47693 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47694 swig_empty_runtime_method_table);
47695 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47696 if (pointer && module) {
47697 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47698 }
47699 return type_list_handle;
47700 }
47701
47702 static swig_type_info **
47703 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47704 swig_type_info **type_pointer;
47705
47706 /* first check if module already created */
47707 type_pointer = SWIG_Python_GetTypeListHandle();
47708 if (type_pointer) {
47709 return type_pointer;
47710 } else {
47711 /* create a new module and variable */
47712 return SWIG_Python_SetTypeListHandle(type_list_handle);
47713 }
47714 }
47715
47716 #ifdef __cplusplus
47717 }
47718 #endif
47719
47720 /* -----------------------------------------------------------------------------*
47721 * Partial Init method
47722 * -----------------------------------------------------------------------------*/
47723
47724 #ifdef SWIG_LINK_RUNTIME
47725 #ifdef __cplusplus
47726 extern "C"
47727 #endif
47728 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47729 #endif
47730
47731 #ifdef __cplusplus
47732 extern "C"
47733 #endif
47734 SWIGEXPORT(void) SWIG_init(void) {
47735 static PyObject *SWIG_globals = 0;
47736 static int typeinit = 0;
47737 PyObject *m, *d;
47738 int i;
47739 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47740
47741 /* Fix SwigMethods to carry the callback ptrs when needed */
47742 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47743
47744 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47745 d = PyModule_GetDict(m);
47746
47747 if (!typeinit) {
47748 #ifdef SWIG_LINK_RUNTIME
47749 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47750 #else
47751 # ifndef SWIG_STATIC_RUNTIME
47752 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47753 # endif
47754 #endif
47755 for (i = 0; swig_types_initial[i]; i++) {
47756 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47757 }
47758 typeinit = 1;
47759 }
47760 SWIG_InstallConstants(d,swig_const_table);
47761
47762
47763 #ifndef wxPyUSE_EXPORT
47764 // Make our API structure a CObject so other modules can import it
47765 // from this module.
47766 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47767 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47768 Py_XDECREF(cobj);
47769 #endif
47770
47771 {
47772 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49429 }
49430 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49431 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49432 {
49433 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49584 }
49585 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49586 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49587 {
49588 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49595 }
49596
49597 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49598
49599
49600 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49601
49602 {
49603 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49610 }
49611 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49612 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49613 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49614 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49615 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49616 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49617 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49618 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49619 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49620 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49621 {
49622 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49626 }
49627 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49628 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49629 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49630 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49631 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49632 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49633 {
49634 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49668 }
49669 {
49670 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49680 }
49681 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49682 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49683 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49684 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49685 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49686 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49687 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49688 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49689 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49690 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49691 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49692 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49693 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49694 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49695 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49696 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49697 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49698 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49699 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49700 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49701 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49702 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49703 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49704 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49705 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49706 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49707 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49708 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49709 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49710 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49711 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49712 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49713 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49714 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49715 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49716 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49717 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49718 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49719 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49720 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49721 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49722 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49723 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49724 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49725 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49726 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49727 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49728 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49729 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49730 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49731 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49732 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49733 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49734 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49735 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49736 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49737 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49738 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49739 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49740 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49741 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49742 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49743 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49744 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49745 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49746 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49747 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49748 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49749 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49750 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49751 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49752 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49753 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49754 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49755 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49756 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49757 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49758 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49759 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49760 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49761 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49762 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49763 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49764 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49765 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49766 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49767 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49768 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49769 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49770 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49771 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49772 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49773 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49774 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49775 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49776 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49777 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49778 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49779 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49780 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49781 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49782 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49783 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49784 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49785 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49786 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49787 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49788 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49789 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49790 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49791 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49792 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49793 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49794 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49795 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49796 {
49797 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49834 }
49835 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49836 {
49837 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49853 }
49854 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49855 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49856 {
49857 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49870 }
49871 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49872 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49873 {
49874 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49881 }
49882 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49883 {
49884 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49906 }
49907 {
49908 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49915 }
49916 {
49917 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49918 }
49919 {
49920 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49921 }
49922 {
49923 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49924 }
49925 {
49926 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49927 }
49928 {
49929 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49930 }
49931 {
49932 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49933 }
49934 {
49935 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49936 }
49937 {
49938 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49939 }
49940
49941 // Initialize threading, some globals and such
49942 __wxPyPreStart(d);
49943
49944
49945 // Although these are defined in __version__ they need to be here too so
49946 // that an assert can be done to ensure that the wxPython and the wxWindows
49947 // versions match.
49948 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49949 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49950 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49951
49952 }
49953
wxWidgets (Impactor)