]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Allow wchar_t for djgpp
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 PyObject* list = PyList_New(count);
2616
2617 if (!list) {
2618 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2619 return NULL;
2620 }
2621
2622 for (int i=0; i<count; i++) {
2623 PyList_SetItem(list, i, wx2PyString(files[i]));
2624 }
2625 return list;
2626 }
2627
2628
2629 static wxPyApp *new_wxPyApp(){
2630 wxPythonApp = new wxPyApp();
2631 return wxPythonApp;
2632 }
2633 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2634
2635 void wxApp_CleanUp() {
2636 __wxPyCleanup();
2637 }
2638
2639
2640 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2641
2642
2643 SWIGINTERNSHORT int
2644 SWIG_AsCharPtr(PyObject *obj, char **val)
2645 {
2646 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2647 return 1;
2648 }
2649 if (val) {
2650 PyErr_Clear();
2651 SWIG_type_error("char *", obj);
2652 }
2653 return 0;
2654 }
2655
2656
2657 SWIGINTERN PyObject *
2658 SWIG_FromCharPtr(const char* cptr)
2659 {
2660 if (cptr) {
2661 size_t size = strlen(cptr);
2662 if (size > INT_MAX) {
2663 return SWIG_NewPointerObj((char*)(cptr),
2664 SWIG_TypeQuery("char *"), 0);
2665 } else {
2666 if (size != 0) {
2667 return PyString_FromStringAndSize(cptr, size);
2668 } else {
2669 return PyString_FromString(cptr);
2670 }
2671 }
2672 }
2673 Py_INCREF(Py_None);
2674 return Py_None;
2675 }
2676
2677
2678 #ifdef __WXMAC__
2679
2680 // A dummy class that raises an exception if used...
2681 class wxEventLoop
2682 {
2683 public:
2684 wxEventLoop() { wxPyRaiseNotImplemented(); }
2685 int Run() { return 0; }
2686 void Exit(int rc = 0) {}
2687 bool Pending() const { return false; }
2688 bool Dispatch() { return false; }
2689 bool IsRunning() const { return false; }
2690 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2691 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2692 };
2693
2694 #else
2695
2696 #include <wx/evtloop.h>
2697
2698 #endif
2699
2700
2701
2702 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2703 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2704 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2705 static PyObject *wxWindow_GetChildren(wxWindow *self){
2706 wxWindowList& list = self->GetChildren();
2707 return wxPy_ConvertList(&list);
2708 }
2709 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2710 #if wxUSE_HOTKEY
2711 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2712 #else
2713 return false;
2714 #endif
2715 }
2716 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2717
2718
2719
2720 return false;
2721
2722 }
2723 static long wxWindow_GetHandle(wxWindow *self){
2724 return wxPyGetWinHandle(self);
2725 }
2726 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2727 self->AssociateHandle((WXWidget)handle);
2728 }
2729
2730 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2731 return wxWindow::FindWindowById(id, parent);
2732 }
2733
2734 wxWindow* wxFindWindowByName( const wxString& name,
2735 const wxWindow *parent = NULL ) {
2736 return wxWindow::FindWindowByName(name, parent);
2737 }
2738
2739 wxWindow* wxFindWindowByLabel( const wxString& label,
2740 const wxWindow *parent = NULL ) {
2741 return wxWindow::FindWindowByLabel(label, parent);
2742 }
2743
2744
2745 #ifdef __WXMSW__
2746 #include <wx/msw/private.h> // to get wxGetWindowId
2747 #endif
2748
2749
2750 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2751 #ifdef __WXMSW__
2752 WXHWND hWnd = (WXHWND)_hWnd;
2753 long id = wxGetWindowId(hWnd);
2754 wxWindow* win = new wxWindow;
2755 parent->AddChild(win);
2756 win->SetEventHandler(win);
2757 win->SetHWND(hWnd);
2758 win->SetId(id);
2759 win->SubclassWin(hWnd);
2760 win->AdoptAttributesFromHWND();
2761 win->SetupColours();
2762 return win;
2763 #else
2764 wxPyRaiseNotImplemented();
2765 return NULL;
2766 #endif
2767 }
2768
2769
2770 PyObject* GetTopLevelWindows() {
2771 return wxPy_ConvertList(&wxTopLevelWindows);
2772 }
2773
2774
2775 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2776 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2777 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2778
2779 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2780
2781 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2782 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2783 wxMenuItemList& list = self->GetMenuItems();
2784 return wxPy_ConvertList(&list);
2785 }
2786 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2787 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2788 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2789 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2790 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2791 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2792 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2793 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2794 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2795 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2796 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2797 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2798 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2799 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2800 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2801 static const wxString wxPyControlNameStr(wxControlNameStr);
2802 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2803 if (clientData) {
2804 wxPyClientData* data = new wxPyClientData(clientData);
2805 return self->Append(item, data);
2806 } else
2807 return self->Append(item);
2808 }
2809 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2810 if (clientData) {
2811 wxPyClientData* data = new wxPyClientData(clientData);
2812 return self->Insert(item, pos, data);
2813 } else
2814 return self->Insert(item, pos);
2815 }
2816 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2817 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2818 if (data) {
2819 Py_INCREF(data->m_obj);
2820 return data->m_obj;
2821 } else {
2822 Py_INCREF(Py_None);
2823 return Py_None;
2824 }
2825 }
2826 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2827 wxPyClientData* data = new wxPyClientData(clientData);
2828 self->SetClientObject(n, data);
2829 }
2830
2831
2832 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2833 wxPyUserData* data = NULL;
2834 if ( userData ) {
2835 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2836 data = new wxPyUserData(userData);
2837 wxPyEndBlockThreads(blocked);
2838 }
2839 return new wxSizerItem(window, proportion, flag, border, data);
2840 }
2841 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2842 wxPyUserData* data = NULL;
2843 if ( userData ) {
2844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2845 data = new wxPyUserData(userData);
2846 wxPyEndBlockThreads(blocked);
2847 }
2848 return new wxSizerItem(width, height, proportion, flag, border, data);
2849 }
2850 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2851 wxPyUserData* data = NULL;
2852 if ( userData ) {
2853 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2854 data = new wxPyUserData(userData);
2855 wxPyEndBlockThreads(blocked);
2856 }
2857 return new wxSizerItem(sizer, proportion, flag, border, data);
2858 }
2859
2860 #include <float.h>
2861 SWIGINTERN int
2862 SWIG_CheckDoubleInRange(double value, double min_value,
2863 double max_value, const char* errmsg)
2864 {
2865 if (value < min_value) {
2866 if (errmsg) {
2867 PyErr_Format(PyExc_OverflowError,
2868 "value %g is less than %s minimum %g",
2869 value, errmsg, min_value);
2870 }
2871 return 0;
2872 } else if (value > max_value) {
2873 if (errmsg) {
2874 PyErr_Format(PyExc_OverflowError,
2875 "value %g is greater than %s maximum %g",
2876 value, errmsg, max_value);
2877 }
2878 return 0;
2879 }
2880 return 1;
2881 }
2882
2883
2884 SWIGINTERN int
2885 SWIG_AsVal_float(PyObject *obj, float *val)
2886 {
2887 const char* errmsg = val ? "float" : (char*)0;
2888 double v;
2889 if (SWIG_AsVal_double(obj, &v)) {
2890 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2891 if (val) *val = (float)(v);
2892 return 1;
2893 } else {
2894 return 0;
2895 }
2896 } else {
2897 PyErr_Clear();
2898 }
2899 if (val) {
2900 SWIG_type_error(errmsg, obj);
2901 }
2902 return 0;
2903 }
2904
2905
2906 SWIGINTERNSHORT float
2907 SWIG_As_float(PyObject* obj)
2908 {
2909 float v;
2910 if (!SWIG_AsVal_float(obj, &v)) {
2911 /*
2912 this is needed to make valgrind/purify happier.
2913 */
2914 memset((void*)&v, 0, sizeof(float));
2915 }
2916 return v;
2917 }
2918
2919
2920 SWIGINTERNSHORT int
2921 SWIG_Check_float(PyObject* obj)
2922 {
2923 return SWIG_AsVal_float(obj, (float*)0);
2924 }
2925
2926
2927 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2928 #define SWIG_From_float PyFloat_FromDouble
2929 /*@@*/
2930
2931 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2932 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2933 if (data) {
2934 Py_INCREF(data->m_obj);
2935 return data->m_obj;
2936 } else {
2937 Py_INCREF(Py_None);
2938 return Py_None;
2939 }
2940 }
2941
2942 // Figure out the type of the sizer item
2943
2944 struct wxPySizerItemInfo {
2945 wxPySizerItemInfo()
2946 : window(NULL), sizer(NULL), gotSize(false),
2947 size(wxDefaultSize), gotPos(false), pos(-1)
2948 {}
2949
2950 wxWindow* window;
2951 wxSizer* sizer;
2952 bool gotSize;
2953 wxSize size;
2954 bool gotPos;
2955 int pos;
2956 };
2957
2958 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2959
2960 wxPySizerItemInfo info;
2961 wxSize size;
2962 wxSize* sizePtr = &size;
2963
2964 // Find out what the type of the item is
2965 // try wxWindow
2966 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2967 PyErr_Clear();
2968 info.window = NULL;
2969
2970 // try wxSizer
2971 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2972 PyErr_Clear();
2973 info.sizer = NULL;
2974
2975 // try wxSize or (w,h)
2976 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2977 info.size = *sizePtr;
2978 info.gotSize = true;
2979 }
2980
2981 // or a single int
2982 if (checkIdx && PyInt_Check(item)) {
2983 info.pos = PyInt_AsLong(item);
2984 info.gotPos = true;
2985 }
2986 }
2987 }
2988
2989 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2990 // no expected type, figure out what kind of error message to generate
2991 if ( !checkSize && !checkIdx )
2992 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2993 else if ( checkSize && !checkIdx )
2994 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2995 else if ( !checkSize && checkIdx)
2996 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2997 else
2998 // can this one happen?
2999 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
3000 }
3001
3002 return info;
3003 }
3004
3005 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3006 if (!self->GetClientObject())
3007 self->SetClientObject(new wxPyOORClientData(_self));
3008 }
3009 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3010
3011 wxPyUserData* data = NULL;
3012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3013 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3014 if ( userData && (info.window || info.sizer || info.gotSize) )
3015 data = new wxPyUserData(userData);
3016 wxPyEndBlockThreads(blocked);
3017
3018 // Now call the real Add method if a valid item type was found
3019 if ( info.window )
3020 return self->Add(info.window, proportion, flag, border, data);
3021 else if ( info.sizer )
3022 return self->Add(info.sizer, proportion, flag, border, data);
3023 else if (info.gotSize)
3024 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3025 proportion, flag, border, data);
3026 else
3027 return NULL;
3028 }
3029 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3030
3031 wxPyUserData* data = NULL;
3032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3033 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3034 if ( userData && (info.window || info.sizer || info.gotSize) )
3035 data = new wxPyUserData(userData);
3036 wxPyEndBlockThreads(blocked);
3037
3038 // Now call the real Insert method if a valid item type was found
3039 if ( info.window )
3040 return self->Insert(before, info.window, proportion, flag, border, data);
3041 else if ( info.sizer )
3042 return self->Insert(before, info.sizer, proportion, flag, border, data);
3043 else if (info.gotSize)
3044 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3045 proportion, flag, border, data);
3046 else
3047 return NULL;
3048 }
3049 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3050
3051 wxPyUserData* data = NULL;
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3054 if ( userData && (info.window || info.sizer || info.gotSize) )
3055 data = new wxPyUserData(userData);
3056 wxPyEndBlockThreads(blocked);
3057
3058 // Now call the real Prepend method if a valid item type was found
3059 if ( info.window )
3060 return self->Prepend(info.window, proportion, flag, border, data);
3061 else if ( info.sizer )
3062 return self->Prepend(info.sizer, proportion, flag, border, data);
3063 else if (info.gotSize)
3064 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3065 proportion, flag, border, data);
3066 else
3067 return NULL;
3068 }
3069 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 return self->Remove(info.window);
3075 else if ( info.sizer )
3076 return self->Remove(info.sizer);
3077 else if ( info.gotPos )
3078 return self->Remove(info.pos);
3079 else
3080 return false;
3081 }
3082 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 return self->Detach(info.window);
3088 else if ( info.sizer )
3089 return self->Detach(info.sizer);
3090 else if ( info.gotPos )
3091 return self->Detach(info.pos);
3092 else
3093 return false;
3094 }
3095 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3098 wxPyEndBlockThreads(blocked);
3099 if ( info.window )
3100 return self->GetItem(info.window);
3101 else if ( info.sizer )
3102 return self->GetItem(info.sizer);
3103 else if ( info.gotPos )
3104 return self->GetItem(info.pos);
3105 else
3106 return NULL;
3107 }
3108 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3111 wxPyEndBlockThreads(blocked);
3112 if ( info.window )
3113 self->SetItemMinSize(info.window, size);
3114 else if ( info.sizer )
3115 self->SetItemMinSize(info.sizer, size);
3116 else if ( info.gotPos )
3117 self->SetItemMinSize(info.pos, size);
3118 }
3119 static PyObject *wxSizer_GetChildren(wxSizer *self){
3120 wxSizerItemList& list = self->GetChildren();
3121 return wxPy_ConvertList(&list);
3122 }
3123 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3124 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3125 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3126 wxPyEndBlockThreads(blocked);
3127 if ( info.window )
3128 return self->Show(info.window, show, recursive);
3129 else if ( info.sizer )
3130 return self->Show(info.sizer, show, recursive);
3131 else if ( info.gotPos )
3132 return self->Show(info.pos, show);
3133 else
3134 return false;
3135 }
3136 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3139 wxPyEndBlockThreads(blocked);
3140 if ( info.window )
3141 return self->IsShown(info.window);
3142 else if ( info.sizer )
3143 return self->IsShown(info.sizer);
3144 else if ( info.gotPos )
3145 return self->IsShown(info.pos);
3146 else
3147 return false;
3148 }
3149
3150 // See pyclasses.h
3151 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3152 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3153 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3154
3155
3156
3157
3158 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3159 {
3160 if (source == Py_None) {
3161 **obj = wxGBPosition(-1,-1);
3162 return true;
3163 }
3164 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3165 }
3166
3167 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3168 {
3169 if (source == Py_None) {
3170 **obj = wxGBSpan(-1,-1);
3171 return true;
3172 }
3173 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3174 }
3175
3176
3177 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3178 self->SetRow(row);
3179 self->SetCol(col);
3180 }
3181 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3183 PyObject* tup = PyTuple_New(2);
3184 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3185 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3186 wxPyEndBlockThreads(blocked);
3187 return tup;
3188 }
3189 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3190 self->SetRowspan(rowspan);
3191 self->SetColspan(colspan);
3192 }
3193 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3195 PyObject* tup = PyTuple_New(2);
3196 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3197 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3198 wxPyEndBlockThreads(blocked);
3199 return tup;
3200 }
3201 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3202 wxPyUserData* data = NULL;
3203 if ( userData ) {
3204 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 data = new wxPyUserData(userData);
3206 wxPyEndBlockThreads(blocked);
3207 }
3208 return new wxGBSizerItem(window, pos, span, flag, border, data);
3209 }
3210 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3211 wxPyUserData* data = NULL;
3212 if ( userData ) {
3213 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3214 data = new wxPyUserData(userData);
3215 wxPyEndBlockThreads(blocked);
3216 }
3217 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3218 }
3219 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3220 wxPyUserData* data = NULL;
3221 if ( userData ) {
3222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3223 data = new wxPyUserData(userData);
3224 wxPyEndBlockThreads(blocked);
3225 }
3226 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3227 }
3228 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3229 int row, col;
3230 self->GetEndPos(row, col);
3231 return wxGBPosition(row, col);
3232 }
3233 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3234
3235 wxPyUserData* data = NULL;
3236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3238 if ( userData && (info.window || info.sizer || info.gotSize) )
3239 data = new wxPyUserData(userData);
3240 wxPyEndBlockThreads(blocked);
3241
3242 // Now call the real Add method if a valid item type was found
3243 if ( info.window )
3244 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3245 else if ( info.sizer )
3246 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3247 else if (info.gotSize)
3248 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3249 pos, span, flag, border, data);
3250 return NULL;
3251 }
3252
3253
3254 #ifdef __cplusplus
3255 extern "C" {
3256 #endif
3257 static int _wrap_EmptyString_set(PyObject *) {
3258 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3259 return 1;
3260 }
3261
3262
3263 static PyObject *_wrap_EmptyString_get(void) {
3264 PyObject *pyobj;
3265
3266 {
3267 #if wxUSE_UNICODE
3268 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3269 #else
3270 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3271 #endif
3272 }
3273 return pyobj;
3274 }
3275
3276
3277 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxObject *arg1 = (wxObject *) 0 ;
3280 wxString result;
3281 PyObject * obj0 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3288 if (SWIG_arg_fail(1)) SWIG_fail;
3289 {
3290 PyThreadState* __tstate = wxPyBeginAllowThreads();
3291 result = wxObject_GetClassName(arg1);
3292
3293 wxPyEndAllowThreads(__tstate);
3294 if (PyErr_Occurred()) SWIG_fail;
3295 }
3296 {
3297 #if wxUSE_UNICODE
3298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3299 #else
3300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3301 #endif
3302 }
3303 return resultobj;
3304 fail:
3305 return NULL;
3306 }
3307
3308
3309 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3310 PyObject *resultobj;
3311 wxObject *arg1 = (wxObject *) 0 ;
3312 PyObject * obj0 = 0 ;
3313 char *kwnames[] = {
3314 (char *) "self", NULL
3315 };
3316
3317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3319 if (SWIG_arg_fail(1)) SWIG_fail;
3320 {
3321 PyThreadState* __tstate = wxPyBeginAllowThreads();
3322 wxObject_Destroy(arg1);
3323
3324 wxPyEndAllowThreads(__tstate);
3325 if (PyErr_Occurred()) SWIG_fail;
3326 }
3327 Py_INCREF(Py_None); resultobj = Py_None;
3328 return resultobj;
3329 fail:
3330 return NULL;
3331 }
3332
3333
3334 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3335 PyObject *obj;
3336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3337 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3338 Py_INCREF(obj);
3339 return Py_BuildValue((char *)"");
3340 }
3341 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3342 PyObject *resultobj;
3343 wxSize *arg1 = (wxSize *) 0 ;
3344 int arg2 ;
3345 PyObject * obj0 = 0 ;
3346 PyObject * obj1 = 0 ;
3347 char *kwnames[] = {
3348 (char *) "self",(char *) "x", NULL
3349 };
3350
3351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3353 if (SWIG_arg_fail(1)) SWIG_fail;
3354 {
3355 arg2 = (int)(SWIG_As_int(obj1));
3356 if (SWIG_arg_fail(2)) SWIG_fail;
3357 }
3358 if (arg1) (arg1)->x = arg2;
3359
3360 Py_INCREF(Py_None); resultobj = Py_None;
3361 return resultobj;
3362 fail:
3363 return NULL;
3364 }
3365
3366
3367 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3368 PyObject *resultobj;
3369 wxSize *arg1 = (wxSize *) 0 ;
3370 int result;
3371 PyObject * obj0 = 0 ;
3372 char *kwnames[] = {
3373 (char *) "self", NULL
3374 };
3375
3376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3378 if (SWIG_arg_fail(1)) SWIG_fail;
3379 result = (int) ((arg1)->x);
3380
3381 {
3382 resultobj = SWIG_From_int((int)(result));
3383 }
3384 return resultobj;
3385 fail:
3386 return NULL;
3387 }
3388
3389
3390 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3391 PyObject *resultobj;
3392 wxSize *arg1 = (wxSize *) 0 ;
3393 int arg2 ;
3394 PyObject * obj0 = 0 ;
3395 PyObject * obj1 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "self",(char *) "y", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3402 if (SWIG_arg_fail(1)) SWIG_fail;
3403 {
3404 arg2 = (int)(SWIG_As_int(obj1));
3405 if (SWIG_arg_fail(2)) SWIG_fail;
3406 }
3407 if (arg1) (arg1)->y = arg2;
3408
3409 Py_INCREF(Py_None); resultobj = Py_None;
3410 return resultobj;
3411 fail:
3412 return NULL;
3413 }
3414
3415
3416 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj;
3418 wxSize *arg1 = (wxSize *) 0 ;
3419 int result;
3420 PyObject * obj0 = 0 ;
3421 char *kwnames[] = {
3422 (char *) "self", NULL
3423 };
3424
3425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3427 if (SWIG_arg_fail(1)) SWIG_fail;
3428 result = (int) ((arg1)->y);
3429
3430 {
3431 resultobj = SWIG_From_int((int)(result));
3432 }
3433 return resultobj;
3434 fail:
3435 return NULL;
3436 }
3437
3438
3439 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3440 PyObject *resultobj;
3441 int arg1 = (int) 0 ;
3442 int arg2 = (int) 0 ;
3443 wxSize *result;
3444 PyObject * obj0 = 0 ;
3445 PyObject * obj1 = 0 ;
3446 char *kwnames[] = {
3447 (char *) "w",(char *) "h", NULL
3448 };
3449
3450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3451 if (obj0) {
3452 {
3453 arg1 = (int)(SWIG_As_int(obj0));
3454 if (SWIG_arg_fail(1)) SWIG_fail;
3455 }
3456 }
3457 if (obj1) {
3458 {
3459 arg2 = (int)(SWIG_As_int(obj1));
3460 if (SWIG_arg_fail(2)) SWIG_fail;
3461 }
3462 }
3463 {
3464 PyThreadState* __tstate = wxPyBeginAllowThreads();
3465 result = (wxSize *)new wxSize(arg1,arg2);
3466
3467 wxPyEndAllowThreads(__tstate);
3468 if (PyErr_Occurred()) SWIG_fail;
3469 }
3470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3471 return resultobj;
3472 fail:
3473 return NULL;
3474 }
3475
3476
3477 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3478 PyObject *resultobj;
3479 wxSize *arg1 = (wxSize *) 0 ;
3480 PyObject * obj0 = 0 ;
3481 char *kwnames[] = {
3482 (char *) "self", NULL
3483 };
3484
3485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3487 if (SWIG_arg_fail(1)) SWIG_fail;
3488 {
3489 PyThreadState* __tstate = wxPyBeginAllowThreads();
3490 delete arg1;
3491
3492 wxPyEndAllowThreads(__tstate);
3493 if (PyErr_Occurred()) SWIG_fail;
3494 }
3495 Py_INCREF(Py_None); resultobj = Py_None;
3496 return resultobj;
3497 fail:
3498 return NULL;
3499 }
3500
3501
3502 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3503 PyObject *resultobj;
3504 wxSize *arg1 = (wxSize *) 0 ;
3505 wxSize *arg2 = 0 ;
3506 bool result;
3507 wxSize temp2 ;
3508 PyObject * obj0 = 0 ;
3509 PyObject * obj1 = 0 ;
3510 char *kwnames[] = {
3511 (char *) "self",(char *) "sz", NULL
3512 };
3513
3514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3516 if (SWIG_arg_fail(1)) SWIG_fail;
3517 {
3518 arg2 = &temp2;
3519 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3520 }
3521 {
3522 PyThreadState* __tstate = wxPyBeginAllowThreads();
3523 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3524
3525 wxPyEndAllowThreads(__tstate);
3526 if (PyErr_Occurred()) SWIG_fail;
3527 }
3528 {
3529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3530 }
3531 return resultobj;
3532 fail:
3533 return NULL;
3534 }
3535
3536
3537 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3538 PyObject *resultobj;
3539 wxSize *arg1 = (wxSize *) 0 ;
3540 wxSize *arg2 = 0 ;
3541 bool result;
3542 wxSize temp2 ;
3543 PyObject * obj0 = 0 ;
3544 PyObject * obj1 = 0 ;
3545 char *kwnames[] = {
3546 (char *) "self",(char *) "sz", NULL
3547 };
3548
3549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3551 if (SWIG_arg_fail(1)) SWIG_fail;
3552 {
3553 arg2 = &temp2;
3554 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3555 }
3556 {
3557 PyThreadState* __tstate = wxPyBeginAllowThreads();
3558 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3559
3560 wxPyEndAllowThreads(__tstate);
3561 if (PyErr_Occurred()) SWIG_fail;
3562 }
3563 {
3564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3565 }
3566 return resultobj;
3567 fail:
3568 return NULL;
3569 }
3570
3571
3572 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3573 PyObject *resultobj;
3574 wxSize *arg1 = (wxSize *) 0 ;
3575 wxSize *arg2 = 0 ;
3576 wxSize result;
3577 wxSize temp2 ;
3578 PyObject * obj0 = 0 ;
3579 PyObject * obj1 = 0 ;
3580 char *kwnames[] = {
3581 (char *) "self",(char *) "sz", NULL
3582 };
3583
3584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3586 if (SWIG_arg_fail(1)) SWIG_fail;
3587 {
3588 arg2 = &temp2;
3589 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3590 }
3591 {
3592 PyThreadState* __tstate = wxPyBeginAllowThreads();
3593 result = (arg1)->operator +((wxSize const &)*arg2);
3594
3595 wxPyEndAllowThreads(__tstate);
3596 if (PyErr_Occurred()) SWIG_fail;
3597 }
3598 {
3599 wxSize * resultptr;
3600 resultptr = new wxSize((wxSize &)(result));
3601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3602 }
3603 return resultobj;
3604 fail:
3605 return NULL;
3606 }
3607
3608
3609 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3610 PyObject *resultobj;
3611 wxSize *arg1 = (wxSize *) 0 ;
3612 wxSize *arg2 = 0 ;
3613 wxSize result;
3614 wxSize temp2 ;
3615 PyObject * obj0 = 0 ;
3616 PyObject * obj1 = 0 ;
3617 char *kwnames[] = {
3618 (char *) "self",(char *) "sz", NULL
3619 };
3620
3621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3623 if (SWIG_arg_fail(1)) SWIG_fail;
3624 {
3625 arg2 = &temp2;
3626 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3627 }
3628 {
3629 PyThreadState* __tstate = wxPyBeginAllowThreads();
3630 result = (arg1)->operator -((wxSize const &)*arg2);
3631
3632 wxPyEndAllowThreads(__tstate);
3633 if (PyErr_Occurred()) SWIG_fail;
3634 }
3635 {
3636 wxSize * resultptr;
3637 resultptr = new wxSize((wxSize &)(result));
3638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3639 }
3640 return resultobj;
3641 fail:
3642 return NULL;
3643 }
3644
3645
3646 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 wxSize *arg1 = (wxSize *) 0 ;
3649 wxSize *arg2 = 0 ;
3650 wxSize temp2 ;
3651 PyObject * obj0 = 0 ;
3652 PyObject * obj1 = 0 ;
3653 char *kwnames[] = {
3654 (char *) "self",(char *) "sz", NULL
3655 };
3656
3657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3659 if (SWIG_arg_fail(1)) SWIG_fail;
3660 {
3661 arg2 = &temp2;
3662 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3663 }
3664 {
3665 PyThreadState* __tstate = wxPyBeginAllowThreads();
3666 (arg1)->IncTo((wxSize const &)*arg2);
3667
3668 wxPyEndAllowThreads(__tstate);
3669 if (PyErr_Occurred()) SWIG_fail;
3670 }
3671 Py_INCREF(Py_None); resultobj = Py_None;
3672 return resultobj;
3673 fail:
3674 return NULL;
3675 }
3676
3677
3678 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3679 PyObject *resultobj;
3680 wxSize *arg1 = (wxSize *) 0 ;
3681 wxSize *arg2 = 0 ;
3682 wxSize temp2 ;
3683 PyObject * obj0 = 0 ;
3684 PyObject * obj1 = 0 ;
3685 char *kwnames[] = {
3686 (char *) "self",(char *) "sz", NULL
3687 };
3688
3689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3691 if (SWIG_arg_fail(1)) SWIG_fail;
3692 {
3693 arg2 = &temp2;
3694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3695 }
3696 {
3697 PyThreadState* __tstate = wxPyBeginAllowThreads();
3698 (arg1)->DecTo((wxSize const &)*arg2);
3699
3700 wxPyEndAllowThreads(__tstate);
3701 if (PyErr_Occurred()) SWIG_fail;
3702 }
3703 Py_INCREF(Py_None); resultobj = Py_None;
3704 return resultobj;
3705 fail:
3706 return NULL;
3707 }
3708
3709
3710 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3711 PyObject *resultobj;
3712 wxSize *arg1 = (wxSize *) 0 ;
3713 int arg2 ;
3714 int arg3 ;
3715 PyObject * obj0 = 0 ;
3716 PyObject * obj1 = 0 ;
3717 PyObject * obj2 = 0 ;
3718 char *kwnames[] = {
3719 (char *) "self",(char *) "w",(char *) "h", NULL
3720 };
3721
3722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3724 if (SWIG_arg_fail(1)) SWIG_fail;
3725 {
3726 arg2 = (int)(SWIG_As_int(obj1));
3727 if (SWIG_arg_fail(2)) SWIG_fail;
3728 }
3729 {
3730 arg3 = (int)(SWIG_As_int(obj2));
3731 if (SWIG_arg_fail(3)) SWIG_fail;
3732 }
3733 {
3734 PyThreadState* __tstate = wxPyBeginAllowThreads();
3735 (arg1)->Set(arg2,arg3);
3736
3737 wxPyEndAllowThreads(__tstate);
3738 if (PyErr_Occurred()) SWIG_fail;
3739 }
3740 Py_INCREF(Py_None); resultobj = Py_None;
3741 return resultobj;
3742 fail:
3743 return NULL;
3744 }
3745
3746
3747 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3748 PyObject *resultobj;
3749 wxSize *arg1 = (wxSize *) 0 ;
3750 int arg2 ;
3751 PyObject * obj0 = 0 ;
3752 PyObject * obj1 = 0 ;
3753 char *kwnames[] = {
3754 (char *) "self",(char *) "w", NULL
3755 };
3756
3757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3759 if (SWIG_arg_fail(1)) SWIG_fail;
3760 {
3761 arg2 = (int)(SWIG_As_int(obj1));
3762 if (SWIG_arg_fail(2)) SWIG_fail;
3763 }
3764 {
3765 PyThreadState* __tstate = wxPyBeginAllowThreads();
3766 (arg1)->SetWidth(arg2);
3767
3768 wxPyEndAllowThreads(__tstate);
3769 if (PyErr_Occurred()) SWIG_fail;
3770 }
3771 Py_INCREF(Py_None); resultobj = Py_None;
3772 return resultobj;
3773 fail:
3774 return NULL;
3775 }
3776
3777
3778 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3779 PyObject *resultobj;
3780 wxSize *arg1 = (wxSize *) 0 ;
3781 int arg2 ;
3782 PyObject * obj0 = 0 ;
3783 PyObject * obj1 = 0 ;
3784 char *kwnames[] = {
3785 (char *) "self",(char *) "h", NULL
3786 };
3787
3788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3790 if (SWIG_arg_fail(1)) SWIG_fail;
3791 {
3792 arg2 = (int)(SWIG_As_int(obj1));
3793 if (SWIG_arg_fail(2)) SWIG_fail;
3794 }
3795 {
3796 PyThreadState* __tstate = wxPyBeginAllowThreads();
3797 (arg1)->SetHeight(arg2);
3798
3799 wxPyEndAllowThreads(__tstate);
3800 if (PyErr_Occurred()) SWIG_fail;
3801 }
3802 Py_INCREF(Py_None); resultobj = Py_None;
3803 return resultobj;
3804 fail:
3805 return NULL;
3806 }
3807
3808
3809 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3810 PyObject *resultobj;
3811 wxSize *arg1 = (wxSize *) 0 ;
3812 int result;
3813 PyObject * obj0 = 0 ;
3814 char *kwnames[] = {
3815 (char *) "self", NULL
3816 };
3817
3818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3820 if (SWIG_arg_fail(1)) SWIG_fail;
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (int)((wxSize const *)arg1)->GetWidth();
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = SWIG_From_int((int)(result));
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj;
3839 wxSize *arg1 = (wxSize *) 0 ;
3840 int result;
3841 PyObject * obj0 = 0 ;
3842 char *kwnames[] = {
3843 (char *) "self", NULL
3844 };
3845
3846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3848 if (SWIG_arg_fail(1)) SWIG_fail;
3849 {
3850 PyThreadState* __tstate = wxPyBeginAllowThreads();
3851 result = (int)((wxSize const *)arg1)->GetHeight();
3852
3853 wxPyEndAllowThreads(__tstate);
3854 if (PyErr_Occurred()) SWIG_fail;
3855 }
3856 {
3857 resultobj = SWIG_From_int((int)(result));
3858 }
3859 return resultobj;
3860 fail:
3861 return NULL;
3862 }
3863
3864
3865 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3866 PyObject *resultobj;
3867 wxSize *arg1 = (wxSize *) 0 ;
3868 bool result;
3869 PyObject * obj0 = 0 ;
3870 char *kwnames[] = {
3871 (char *) "self", NULL
3872 };
3873
3874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3876 if (SWIG_arg_fail(1)) SWIG_fail;
3877 {
3878 PyThreadState* __tstate = wxPyBeginAllowThreads();
3879 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3880
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 {
3885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3886 }
3887 return resultobj;
3888 fail:
3889 return NULL;
3890 }
3891
3892
3893 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3894 PyObject *resultobj;
3895 wxSize *arg1 = (wxSize *) 0 ;
3896 wxSize *arg2 = 0 ;
3897 wxSize temp2 ;
3898 PyObject * obj0 = 0 ;
3899 PyObject * obj1 = 0 ;
3900 char *kwnames[] = {
3901 (char *) "self",(char *) "size", NULL
3902 };
3903
3904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3906 if (SWIG_arg_fail(1)) SWIG_fail;
3907 {
3908 arg2 = &temp2;
3909 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3910 }
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 (arg1)->SetDefaults((wxSize const &)*arg2);
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 Py_INCREF(Py_None); resultobj = Py_None;
3919 return resultobj;
3920 fail:
3921 return NULL;
3922 }
3923
3924
3925 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3926 PyObject *resultobj;
3927 wxSize *arg1 = (wxSize *) 0 ;
3928 PyObject *result;
3929 PyObject * obj0 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "self", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3936 if (SWIG_arg_fail(1)) SWIG_fail;
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 result = (PyObject *)wxSize_Get(arg1);
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 resultobj = result;
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3952 PyObject *obj;
3953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3954 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3955 Py_INCREF(obj);
3956 return Py_BuildValue((char *)"");
3957 }
3958 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3959 PyObject *resultobj;
3960 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3961 double arg2 ;
3962 PyObject * obj0 = 0 ;
3963 PyObject * obj1 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self",(char *) "x", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 {
3972 arg2 = (double)(SWIG_As_double(obj1));
3973 if (SWIG_arg_fail(2)) SWIG_fail;
3974 }
3975 if (arg1) (arg1)->x = arg2;
3976
3977 Py_INCREF(Py_None); resultobj = Py_None;
3978 return resultobj;
3979 fail:
3980 return NULL;
3981 }
3982
3983
3984 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3985 PyObject *resultobj;
3986 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3987 double result;
3988 PyObject * obj0 = 0 ;
3989 char *kwnames[] = {
3990 (char *) "self", NULL
3991 };
3992
3993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3995 if (SWIG_arg_fail(1)) SWIG_fail;
3996 result = (double) ((arg1)->x);
3997
3998 {
3999 resultobj = SWIG_From_double((double)(result));
4000 }
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj;
4009 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4010 double arg2 ;
4011 PyObject * obj0 = 0 ;
4012 PyObject * obj1 = 0 ;
4013 char *kwnames[] = {
4014 (char *) "self",(char *) "y", NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 {
4021 arg2 = (double)(SWIG_As_double(obj1));
4022 if (SWIG_arg_fail(2)) SWIG_fail;
4023 }
4024 if (arg1) (arg1)->y = arg2;
4025
4026 Py_INCREF(Py_None); resultobj = Py_None;
4027 return resultobj;
4028 fail:
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4036 double result;
4037 PyObject * obj0 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "self", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4044 if (SWIG_arg_fail(1)) SWIG_fail;
4045 result = (double) ((arg1)->y);
4046
4047 {
4048 resultobj = SWIG_From_double((double)(result));
4049 }
4050 return resultobj;
4051 fail:
4052 return NULL;
4053 }
4054
4055
4056 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4057 PyObject *resultobj;
4058 double arg1 = (double) 0.0 ;
4059 double arg2 = (double) 0.0 ;
4060 wxRealPoint *result;
4061 PyObject * obj0 = 0 ;
4062 PyObject * obj1 = 0 ;
4063 char *kwnames[] = {
4064 (char *) "x",(char *) "y", NULL
4065 };
4066
4067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4068 if (obj0) {
4069 {
4070 arg1 = (double)(SWIG_As_double(obj0));
4071 if (SWIG_arg_fail(1)) SWIG_fail;
4072 }
4073 }
4074 if (obj1) {
4075 {
4076 arg2 = (double)(SWIG_As_double(obj1));
4077 if (SWIG_arg_fail(2)) SWIG_fail;
4078 }
4079 }
4080 {
4081 PyThreadState* __tstate = wxPyBeginAllowThreads();
4082 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4083
4084 wxPyEndAllowThreads(__tstate);
4085 if (PyErr_Occurred()) SWIG_fail;
4086 }
4087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4088 return resultobj;
4089 fail:
4090 return NULL;
4091 }
4092
4093
4094 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj;
4096 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4097 PyObject * obj0 = 0 ;
4098 char *kwnames[] = {
4099 (char *) "self", NULL
4100 };
4101
4102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 {
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 delete arg1;
4108
4109 wxPyEndAllowThreads(__tstate);
4110 if (PyErr_Occurred()) SWIG_fail;
4111 }
4112 Py_INCREF(Py_None); resultobj = Py_None;
4113 return resultobj;
4114 fail:
4115 return NULL;
4116 }
4117
4118
4119 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4120 PyObject *resultobj;
4121 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4122 wxRealPoint *arg2 = 0 ;
4123 bool result;
4124 wxRealPoint temp2 ;
4125 PyObject * obj0 = 0 ;
4126 PyObject * obj1 = 0 ;
4127 char *kwnames[] = {
4128 (char *) "self",(char *) "pt", NULL
4129 };
4130
4131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4133 if (SWIG_arg_fail(1)) SWIG_fail;
4134 {
4135 arg2 = &temp2;
4136 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4137 }
4138 {
4139 PyThreadState* __tstate = wxPyBeginAllowThreads();
4140 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4141
4142 wxPyEndAllowThreads(__tstate);
4143 if (PyErr_Occurred()) SWIG_fail;
4144 }
4145 {
4146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4147 }
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj;
4156 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4157 wxRealPoint *arg2 = 0 ;
4158 bool result;
4159 wxRealPoint temp2 ;
4160 PyObject * obj0 = 0 ;
4161 PyObject * obj1 = 0 ;
4162 char *kwnames[] = {
4163 (char *) "self",(char *) "pt", NULL
4164 };
4165
4166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4168 if (SWIG_arg_fail(1)) SWIG_fail;
4169 {
4170 arg2 = &temp2;
4171 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4172 }
4173 {
4174 PyThreadState* __tstate = wxPyBeginAllowThreads();
4175 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4176
4177 wxPyEndAllowThreads(__tstate);
4178 if (PyErr_Occurred()) SWIG_fail;
4179 }
4180 {
4181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4182 }
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj;
4191 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4192 wxRealPoint *arg2 = 0 ;
4193 wxRealPoint result;
4194 wxRealPoint temp2 ;
4195 PyObject * obj0 = 0 ;
4196 PyObject * obj1 = 0 ;
4197 char *kwnames[] = {
4198 (char *) "self",(char *) "pt", NULL
4199 };
4200
4201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4203 if (SWIG_arg_fail(1)) SWIG_fail;
4204 {
4205 arg2 = &temp2;
4206 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4207 }
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 wxRealPoint * resultptr;
4217 resultptr = new wxRealPoint((wxRealPoint &)(result));
4218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4219 }
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj;
4228 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4229 wxRealPoint *arg2 = 0 ;
4230 wxRealPoint result;
4231 wxRealPoint temp2 ;
4232 PyObject * obj0 = 0 ;
4233 PyObject * obj1 = 0 ;
4234 char *kwnames[] = {
4235 (char *) "self",(char *) "pt", NULL
4236 };
4237
4238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4240 if (SWIG_arg_fail(1)) SWIG_fail;
4241 {
4242 arg2 = &temp2;
4243 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4244 }
4245 {
4246 PyThreadState* __tstate = wxPyBeginAllowThreads();
4247 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4248
4249 wxPyEndAllowThreads(__tstate);
4250 if (PyErr_Occurred()) SWIG_fail;
4251 }
4252 {
4253 wxRealPoint * resultptr;
4254 resultptr = new wxRealPoint((wxRealPoint &)(result));
4255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4256 }
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4264 PyObject *resultobj;
4265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4266 double arg2 ;
4267 double arg3 ;
4268 PyObject * obj0 = 0 ;
4269 PyObject * obj1 = 0 ;
4270 PyObject * obj2 = 0 ;
4271 char *kwnames[] = {
4272 (char *) "self",(char *) "x",(char *) "y", NULL
4273 };
4274
4275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4277 if (SWIG_arg_fail(1)) SWIG_fail;
4278 {
4279 arg2 = (double)(SWIG_As_double(obj1));
4280 if (SWIG_arg_fail(2)) SWIG_fail;
4281 }
4282 {
4283 arg3 = (double)(SWIG_As_double(obj2));
4284 if (SWIG_arg_fail(3)) SWIG_fail;
4285 }
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 wxRealPoint_Set(arg1,arg2,arg3);
4289
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 Py_INCREF(Py_None); resultobj = Py_None;
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj;
4302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4303 PyObject *result;
4304 PyObject * obj0 = 0 ;
4305 char *kwnames[] = {
4306 (char *) "self", NULL
4307 };
4308
4309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4311 if (SWIG_arg_fail(1)) SWIG_fail;
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (PyObject *)wxRealPoint_Get(arg1);
4315
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = result;
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4327 PyObject *obj;
4328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4329 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4330 Py_INCREF(obj);
4331 return Py_BuildValue((char *)"");
4332 }
4333 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4334 PyObject *resultobj;
4335 wxPoint *arg1 = (wxPoint *) 0 ;
4336 int arg2 ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 char *kwnames[] = {
4340 (char *) "self",(char *) "x", NULL
4341 };
4342
4343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4345 if (SWIG_arg_fail(1)) SWIG_fail;
4346 {
4347 arg2 = (int)(SWIG_As_int(obj1));
4348 if (SWIG_arg_fail(2)) SWIG_fail;
4349 }
4350 if (arg1) (arg1)->x = arg2;
4351
4352 Py_INCREF(Py_None); resultobj = Py_None;
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj;
4361 wxPoint *arg1 = (wxPoint *) 0 ;
4362 int result;
4363 PyObject * obj0 = 0 ;
4364 char *kwnames[] = {
4365 (char *) "self", NULL
4366 };
4367
4368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4370 if (SWIG_arg_fail(1)) SWIG_fail;
4371 result = (int) ((arg1)->x);
4372
4373 {
4374 resultobj = SWIG_From_int((int)(result));
4375 }
4376 return resultobj;
4377 fail:
4378 return NULL;
4379 }
4380
4381
4382 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj;
4384 wxPoint *arg1 = (wxPoint *) 0 ;
4385 int arg2 ;
4386 PyObject * obj0 = 0 ;
4387 PyObject * obj1 = 0 ;
4388 char *kwnames[] = {
4389 (char *) "self",(char *) "y", NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 {
4396 arg2 = (int)(SWIG_As_int(obj1));
4397 if (SWIG_arg_fail(2)) SWIG_fail;
4398 }
4399 if (arg1) (arg1)->y = arg2;
4400
4401 Py_INCREF(Py_None); resultobj = Py_None;
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj;
4410 wxPoint *arg1 = (wxPoint *) 0 ;
4411 int result;
4412 PyObject * obj0 = 0 ;
4413 char *kwnames[] = {
4414 (char *) "self", NULL
4415 };
4416
4417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4419 if (SWIG_arg_fail(1)) SWIG_fail;
4420 result = (int) ((arg1)->y);
4421
4422 {
4423 resultobj = SWIG_From_int((int)(result));
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj;
4433 int arg1 = (int) 0 ;
4434 int arg2 = (int) 0 ;
4435 wxPoint *result;
4436 PyObject * obj0 = 0 ;
4437 PyObject * obj1 = 0 ;
4438 char *kwnames[] = {
4439 (char *) "x",(char *) "y", NULL
4440 };
4441
4442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4443 if (obj0) {
4444 {
4445 arg1 = (int)(SWIG_As_int(obj0));
4446 if (SWIG_arg_fail(1)) SWIG_fail;
4447 }
4448 }
4449 if (obj1) {
4450 {
4451 arg2 = (int)(SWIG_As_int(obj1));
4452 if (SWIG_arg_fail(2)) SWIG_fail;
4453 }
4454 }
4455 {
4456 PyThreadState* __tstate = wxPyBeginAllowThreads();
4457 result = (wxPoint *)new wxPoint(arg1,arg2);
4458
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4463 return resultobj;
4464 fail:
4465 return NULL;
4466 }
4467
4468
4469 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4470 PyObject *resultobj;
4471 wxPoint *arg1 = (wxPoint *) 0 ;
4472 PyObject * obj0 = 0 ;
4473 char *kwnames[] = {
4474 (char *) "self", NULL
4475 };
4476
4477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4479 if (SWIG_arg_fail(1)) SWIG_fail;
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 delete arg1;
4483
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 Py_INCREF(Py_None); resultobj = Py_None;
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj;
4496 wxPoint *arg1 = (wxPoint *) 0 ;
4497 wxPoint *arg2 = 0 ;
4498 bool result;
4499 wxPoint temp2 ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 char *kwnames[] = {
4503 (char *) "self",(char *) "pt", NULL
4504 };
4505
4506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4508 if (SWIG_arg_fail(1)) SWIG_fail;
4509 {
4510 arg2 = &temp2;
4511 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4512 }
4513 {
4514 PyThreadState* __tstate = wxPyBeginAllowThreads();
4515 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4516
4517 wxPyEndAllowThreads(__tstate);
4518 if (PyErr_Occurred()) SWIG_fail;
4519 }
4520 {
4521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4522 }
4523 return resultobj;
4524 fail:
4525 return NULL;
4526 }
4527
4528
4529 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4530 PyObject *resultobj;
4531 wxPoint *arg1 = (wxPoint *) 0 ;
4532 wxPoint *arg2 = 0 ;
4533 bool result;
4534 wxPoint temp2 ;
4535 PyObject * obj0 = 0 ;
4536 PyObject * obj1 = 0 ;
4537 char *kwnames[] = {
4538 (char *) "self",(char *) "pt", NULL
4539 };
4540
4541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4543 if (SWIG_arg_fail(1)) SWIG_fail;
4544 {
4545 arg2 = &temp2;
4546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4547 }
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4551
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 {
4556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4557 }
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4565 PyObject *resultobj;
4566 wxPoint *arg1 = (wxPoint *) 0 ;
4567 wxPoint *arg2 = 0 ;
4568 wxPoint result;
4569 wxPoint temp2 ;
4570 PyObject * obj0 = 0 ;
4571 PyObject * obj1 = 0 ;
4572 char *kwnames[] = {
4573 (char *) "self",(char *) "pt", NULL
4574 };
4575
4576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4578 if (SWIG_arg_fail(1)) SWIG_fail;
4579 {
4580 arg2 = &temp2;
4581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4582 }
4583 {
4584 PyThreadState* __tstate = wxPyBeginAllowThreads();
4585 result = (arg1)->operator +((wxPoint const &)*arg2);
4586
4587 wxPyEndAllowThreads(__tstate);
4588 if (PyErr_Occurred()) SWIG_fail;
4589 }
4590 {
4591 wxPoint * resultptr;
4592 resultptr = new wxPoint((wxPoint &)(result));
4593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4594 }
4595 return resultobj;
4596 fail:
4597 return NULL;
4598 }
4599
4600
4601 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4602 PyObject *resultobj;
4603 wxPoint *arg1 = (wxPoint *) 0 ;
4604 wxPoint *arg2 = 0 ;
4605 wxPoint result;
4606 wxPoint temp2 ;
4607 PyObject * obj0 = 0 ;
4608 PyObject * obj1 = 0 ;
4609 char *kwnames[] = {
4610 (char *) "self",(char *) "pt", NULL
4611 };
4612
4613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4615 if (SWIG_arg_fail(1)) SWIG_fail;
4616 {
4617 arg2 = &temp2;
4618 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4619 }
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 result = (arg1)->operator -((wxPoint const &)*arg2);
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 {
4628 wxPoint * resultptr;
4629 resultptr = new wxPoint((wxPoint &)(result));
4630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4631 }
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj;
4640 wxPoint *arg1 = (wxPoint *) 0 ;
4641 wxPoint *arg2 = 0 ;
4642 wxPoint *result;
4643 wxPoint temp2 ;
4644 PyObject * obj0 = 0 ;
4645 PyObject * obj1 = 0 ;
4646 char *kwnames[] = {
4647 (char *) "self",(char *) "pt", NULL
4648 };
4649
4650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4652 if (SWIG_arg_fail(1)) SWIG_fail;
4653 {
4654 arg2 = &temp2;
4655 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4656 }
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 {
4660 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4661 result = (wxPoint *) &_result_ref;
4662 }
4663
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj;
4676 wxPoint *arg1 = (wxPoint *) 0 ;
4677 wxPoint *arg2 = 0 ;
4678 wxPoint *result;
4679 wxPoint temp2 ;
4680 PyObject * obj0 = 0 ;
4681 PyObject * obj1 = 0 ;
4682 char *kwnames[] = {
4683 (char *) "self",(char *) "pt", NULL
4684 };
4685
4686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4688 if (SWIG_arg_fail(1)) SWIG_fail;
4689 {
4690 arg2 = &temp2;
4691 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4692 }
4693 {
4694 PyThreadState* __tstate = wxPyBeginAllowThreads();
4695 {
4696 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4697 result = (wxPoint *) &_result_ref;
4698 }
4699
4700 wxPyEndAllowThreads(__tstate);
4701 if (PyErr_Occurred()) SWIG_fail;
4702 }
4703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4711 PyObject *resultobj;
4712 wxPoint *arg1 = (wxPoint *) 0 ;
4713 long arg2 ;
4714 long arg3 ;
4715 PyObject * obj0 = 0 ;
4716 PyObject * obj1 = 0 ;
4717 PyObject * obj2 = 0 ;
4718 char *kwnames[] = {
4719 (char *) "self",(char *) "x",(char *) "y", NULL
4720 };
4721
4722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4724 if (SWIG_arg_fail(1)) SWIG_fail;
4725 {
4726 arg2 = (long)(SWIG_As_long(obj1));
4727 if (SWIG_arg_fail(2)) SWIG_fail;
4728 }
4729 {
4730 arg3 = (long)(SWIG_As_long(obj2));
4731 if (SWIG_arg_fail(3)) SWIG_fail;
4732 }
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 wxPoint_Set(arg1,arg2,arg3);
4736
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 Py_INCREF(Py_None); resultobj = Py_None;
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj;
4749 wxPoint *arg1 = (wxPoint *) 0 ;
4750 PyObject *result;
4751 PyObject * obj0 = 0 ;
4752 char *kwnames[] = {
4753 (char *) "self", NULL
4754 };
4755
4756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4758 if (SWIG_arg_fail(1)) SWIG_fail;
4759 {
4760 PyThreadState* __tstate = wxPyBeginAllowThreads();
4761 result = (PyObject *)wxPoint_Get(arg1);
4762
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 resultobj = result;
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4774 PyObject *obj;
4775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4776 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4777 Py_INCREF(obj);
4778 return Py_BuildValue((char *)"");
4779 }
4780 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4781 PyObject *resultobj;
4782 int arg1 = (int) 0 ;
4783 int arg2 = (int) 0 ;
4784 int arg3 = (int) 0 ;
4785 int arg4 = (int) 0 ;
4786 wxRect *result;
4787 PyObject * obj0 = 0 ;
4788 PyObject * obj1 = 0 ;
4789 PyObject * obj2 = 0 ;
4790 PyObject * obj3 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4796 if (obj0) {
4797 {
4798 arg1 = (int)(SWIG_As_int(obj0));
4799 if (SWIG_arg_fail(1)) SWIG_fail;
4800 }
4801 }
4802 if (obj1) {
4803 {
4804 arg2 = (int)(SWIG_As_int(obj1));
4805 if (SWIG_arg_fail(2)) SWIG_fail;
4806 }
4807 }
4808 if (obj2) {
4809 {
4810 arg3 = (int)(SWIG_As_int(obj2));
4811 if (SWIG_arg_fail(3)) SWIG_fail;
4812 }
4813 }
4814 if (obj3) {
4815 {
4816 arg4 = (int)(SWIG_As_int(obj3));
4817 if (SWIG_arg_fail(4)) SWIG_fail;
4818 }
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4823
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj;
4836 wxPoint *arg1 = 0 ;
4837 wxPoint *arg2 = 0 ;
4838 wxRect *result;
4839 wxPoint temp1 ;
4840 wxPoint temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char *kwnames[] = {
4844 (char *) "topLeft",(char *) "bottomRight", NULL
4845 };
4846
4847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4848 {
4849 arg1 = &temp1;
4850 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4851 }
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4859
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj;
4872 wxPoint *arg1 = 0 ;
4873 wxSize *arg2 = 0 ;
4874 wxRect *result;
4875 wxPoint temp1 ;
4876 wxSize temp2 ;
4877 PyObject * obj0 = 0 ;
4878 PyObject * obj1 = 0 ;
4879 char *kwnames[] = {
4880 (char *) "pos",(char *) "size", NULL
4881 };
4882
4883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4884 {
4885 arg1 = &temp1;
4886 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4887 }
4888 {
4889 arg2 = &temp2;
4890 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4891 }
4892 {
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4895
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4907 PyObject *resultobj;
4908 wxSize *arg1 = 0 ;
4909 wxRect *result;
4910 wxSize temp1 ;
4911 PyObject * obj0 = 0 ;
4912 char *kwnames[] = {
4913 (char *) "size", NULL
4914 };
4915
4916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4917 {
4918 arg1 = &temp1;
4919 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4920 }
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4924
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4929 return resultobj;
4930 fail:
4931 return NULL;
4932 }
4933
4934
4935 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4936 PyObject *resultobj;
4937 wxRect *arg1 = (wxRect *) 0 ;
4938 PyObject * obj0 = 0 ;
4939 char *kwnames[] = {
4940 (char *) "self", NULL
4941 };
4942
4943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4945 if (SWIG_arg_fail(1)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 delete arg1;
4949
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 Py_INCREF(Py_None); resultobj = Py_None;
4954 return resultobj;
4955 fail:
4956 return NULL;
4957 }
4958
4959
4960 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4961 PyObject *resultobj;
4962 wxRect *arg1 = (wxRect *) 0 ;
4963 int result;
4964 PyObject * obj0 = 0 ;
4965 char *kwnames[] = {
4966 (char *) "self", NULL
4967 };
4968
4969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4971 if (SWIG_arg_fail(1)) SWIG_fail;
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (int)((wxRect const *)arg1)->GetX();
4975
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 {
4980 resultobj = SWIG_From_int((int)(result));
4981 }
4982 return resultobj;
4983 fail:
4984 return NULL;
4985 }
4986
4987
4988 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj;
4990 wxRect *arg1 = (wxRect *) 0 ;
4991 int arg2 ;
4992 PyObject * obj0 = 0 ;
4993 PyObject * obj1 = 0 ;
4994 char *kwnames[] = {
4995 (char *) "self",(char *) "x", NULL
4996 };
4997
4998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5000 if (SWIG_arg_fail(1)) SWIG_fail;
5001 {
5002 arg2 = (int)(SWIG_As_int(obj1));
5003 if (SWIG_arg_fail(2)) SWIG_fail;
5004 }
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 (arg1)->SetX(arg2);
5008
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 Py_INCREF(Py_None); resultobj = Py_None;
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj;
5021 wxRect *arg1 = (wxRect *) 0 ;
5022 int result;
5023 PyObject * obj0 = 0 ;
5024 char *kwnames[] = {
5025 (char *) "self", NULL
5026 };
5027
5028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5030 if (SWIG_arg_fail(1)) SWIG_fail;
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 result = (int)(arg1)->GetY();
5034
5035 wxPyEndAllowThreads(__tstate);
5036 if (PyErr_Occurred()) SWIG_fail;
5037 }
5038 {
5039 resultobj = SWIG_From_int((int)(result));
5040 }
5041 return resultobj;
5042 fail:
5043 return NULL;
5044 }
5045
5046
5047 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5048 PyObject *resultobj;
5049 wxRect *arg1 = (wxRect *) 0 ;
5050 int arg2 ;
5051 PyObject * obj0 = 0 ;
5052 PyObject * obj1 = 0 ;
5053 char *kwnames[] = {
5054 (char *) "self",(char *) "y", NULL
5055 };
5056
5057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5059 if (SWIG_arg_fail(1)) SWIG_fail;
5060 {
5061 arg2 = (int)(SWIG_As_int(obj1));
5062 if (SWIG_arg_fail(2)) SWIG_fail;
5063 }
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 (arg1)->SetY(arg2);
5067
5068 wxPyEndAllowThreads(__tstate);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 Py_INCREF(Py_None); resultobj = Py_None;
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5079 PyObject *resultobj;
5080 wxRect *arg1 = (wxRect *) 0 ;
5081 int result;
5082 PyObject * obj0 = 0 ;
5083 char *kwnames[] = {
5084 (char *) "self", NULL
5085 };
5086
5087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5089 if (SWIG_arg_fail(1)) SWIG_fail;
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = (int)((wxRect const *)arg1)->GetWidth();
5093
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = SWIG_From_int((int)(result));
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj;
5108 wxRect *arg1 = (wxRect *) 0 ;
5109 int arg2 ;
5110 PyObject * obj0 = 0 ;
5111 PyObject * obj1 = 0 ;
5112 char *kwnames[] = {
5113 (char *) "self",(char *) "w", NULL
5114 };
5115
5116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5118 if (SWIG_arg_fail(1)) SWIG_fail;
5119 {
5120 arg2 = (int)(SWIG_As_int(obj1));
5121 if (SWIG_arg_fail(2)) SWIG_fail;
5122 }
5123 {
5124 PyThreadState* __tstate = wxPyBeginAllowThreads();
5125 (arg1)->SetWidth(arg2);
5126
5127 wxPyEndAllowThreads(__tstate);
5128 if (PyErr_Occurred()) SWIG_fail;
5129 }
5130 Py_INCREF(Py_None); resultobj = Py_None;
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5138 PyObject *resultobj;
5139 wxRect *arg1 = (wxRect *) 0 ;
5140 int result;
5141 PyObject * obj0 = 0 ;
5142 char *kwnames[] = {
5143 (char *) "self", NULL
5144 };
5145
5146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5148 if (SWIG_arg_fail(1)) SWIG_fail;
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 result = (int)((wxRect const *)arg1)->GetHeight();
5152
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 {
5157 resultobj = SWIG_From_int((int)(result));
5158 }
5159 return resultobj;
5160 fail:
5161 return NULL;
5162 }
5163
5164
5165 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5166 PyObject *resultobj;
5167 wxRect *arg1 = (wxRect *) 0 ;
5168 int arg2 ;
5169 PyObject * obj0 = 0 ;
5170 PyObject * obj1 = 0 ;
5171 char *kwnames[] = {
5172 (char *) "self",(char *) "h", NULL
5173 };
5174
5175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5177 if (SWIG_arg_fail(1)) SWIG_fail;
5178 {
5179 arg2 = (int)(SWIG_As_int(obj1));
5180 if (SWIG_arg_fail(2)) SWIG_fail;
5181 }
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 (arg1)->SetHeight(arg2);
5185
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 Py_INCREF(Py_None); resultobj = Py_None;
5190 return resultobj;
5191 fail:
5192 return NULL;
5193 }
5194
5195
5196 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj;
5198 wxRect *arg1 = (wxRect *) 0 ;
5199 wxPoint result;
5200 PyObject * obj0 = 0 ;
5201 char *kwnames[] = {
5202 (char *) "self", NULL
5203 };
5204
5205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5207 if (SWIG_arg_fail(1)) SWIG_fail;
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 result = ((wxRect const *)arg1)->GetPosition();
5211
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 {
5216 wxPoint * resultptr;
5217 resultptr = new wxPoint((wxPoint &)(result));
5218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5219 }
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj;
5228 wxRect *arg1 = (wxRect *) 0 ;
5229 wxPoint *arg2 = 0 ;
5230 wxPoint temp2 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5233 char *kwnames[] = {
5234 (char *) "self",(char *) "p", NULL
5235 };
5236
5237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5239 if (SWIG_arg_fail(1)) SWIG_fail;
5240 {
5241 arg2 = &temp2;
5242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5243 }
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 (arg1)->SetPosition((wxPoint const &)*arg2);
5247
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 Py_INCREF(Py_None); resultobj = Py_None;
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj;
5260 wxRect *arg1 = (wxRect *) 0 ;
5261 wxSize result;
5262 PyObject * obj0 = 0 ;
5263 char *kwnames[] = {
5264 (char *) "self", NULL
5265 };
5266
5267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5269 if (SWIG_arg_fail(1)) SWIG_fail;
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = ((wxRect const *)arg1)->GetSize();
5273
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 {
5278 wxSize * resultptr;
5279 resultptr = new wxSize((wxSize &)(result));
5280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5281 }
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5289 PyObject *resultobj;
5290 wxRect *arg1 = (wxRect *) 0 ;
5291 wxSize *arg2 = 0 ;
5292 wxSize temp2 ;
5293 PyObject * obj0 = 0 ;
5294 PyObject * obj1 = 0 ;
5295 char *kwnames[] = {
5296 (char *) "self",(char *) "s", NULL
5297 };
5298
5299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5301 if (SWIG_arg_fail(1)) SWIG_fail;
5302 {
5303 arg2 = &temp2;
5304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5305 }
5306 {
5307 PyThreadState* __tstate = wxPyBeginAllowThreads();
5308 (arg1)->SetSize((wxSize const &)*arg2);
5309
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 Py_INCREF(Py_None); resultobj = Py_None;
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj;
5322 wxRect *arg1 = (wxRect *) 0 ;
5323 bool result;
5324 PyObject * obj0 = 0 ;
5325 char *kwnames[] = {
5326 (char *) "self", NULL
5327 };
5328
5329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5331 if (SWIG_arg_fail(1)) SWIG_fail;
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 result = (bool)((wxRect const *)arg1)->IsEmpty();
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 {
5340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5341 }
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5349 PyObject *resultobj;
5350 wxRect *arg1 = (wxRect *) 0 ;
5351 wxPoint result;
5352 PyObject * obj0 = 0 ;
5353 char *kwnames[] = {
5354 (char *) "self", NULL
5355 };
5356
5357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5359 if (SWIG_arg_fail(1)) SWIG_fail;
5360 {
5361 PyThreadState* __tstate = wxPyBeginAllowThreads();
5362 result = ((wxRect const *)arg1)->GetTopLeft();
5363
5364 wxPyEndAllowThreads(__tstate);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 wxPoint * resultptr;
5369 resultptr = new wxPoint((wxPoint &)(result));
5370 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5371 }
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj;
5380 wxRect *arg1 = (wxRect *) 0 ;
5381 wxPoint *arg2 = 0 ;
5382 wxPoint temp2 ;
5383 PyObject * obj0 = 0 ;
5384 PyObject * obj1 = 0 ;
5385 char *kwnames[] = {
5386 (char *) "self",(char *) "p", NULL
5387 };
5388
5389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5391 if (SWIG_arg_fail(1)) SWIG_fail;
5392 {
5393 arg2 = &temp2;
5394 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5395 }
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5399
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 Py_INCREF(Py_None); resultobj = Py_None;
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj;
5412 wxRect *arg1 = (wxRect *) 0 ;
5413 wxPoint result;
5414 PyObject * obj0 = 0 ;
5415 char *kwnames[] = {
5416 (char *) "self", NULL
5417 };
5418
5419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5421 if (SWIG_arg_fail(1)) SWIG_fail;
5422 {
5423 PyThreadState* __tstate = wxPyBeginAllowThreads();
5424 result = ((wxRect const *)arg1)->GetBottomRight();
5425
5426 wxPyEndAllowThreads(__tstate);
5427 if (PyErr_Occurred()) SWIG_fail;
5428 }
5429 {
5430 wxPoint * resultptr;
5431 resultptr = new wxPoint((wxPoint &)(result));
5432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj;
5442 wxRect *arg1 = (wxRect *) 0 ;
5443 wxPoint *arg2 = 0 ;
5444 wxPoint temp2 ;
5445 PyObject * obj0 = 0 ;
5446 PyObject * obj1 = 0 ;
5447 char *kwnames[] = {
5448 (char *) "self",(char *) "p", NULL
5449 };
5450
5451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5453 if (SWIG_arg_fail(1)) SWIG_fail;
5454 {
5455 arg2 = &temp2;
5456 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5457 }
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5461
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 Py_INCREF(Py_None); resultobj = Py_None;
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj;
5474 wxRect *arg1 = (wxRect *) 0 ;
5475 int result;
5476 PyObject * obj0 = 0 ;
5477 char *kwnames[] = {
5478 (char *) "self", NULL
5479 };
5480
5481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5483 if (SWIG_arg_fail(1)) SWIG_fail;
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (int)((wxRect const *)arg1)->GetLeft();
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 resultobj = SWIG_From_int((int)(result));
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5501 PyObject *resultobj;
5502 wxRect *arg1 = (wxRect *) 0 ;
5503 int result;
5504 PyObject * obj0 = 0 ;
5505 char *kwnames[] = {
5506 (char *) "self", NULL
5507 };
5508
5509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5511 if (SWIG_arg_fail(1)) SWIG_fail;
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = (int)((wxRect const *)arg1)->GetTop();
5515
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 {
5520 resultobj = SWIG_From_int((int)(result));
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj;
5530 wxRect *arg1 = (wxRect *) 0 ;
5531 int result;
5532 PyObject * obj0 = 0 ;
5533 char *kwnames[] = {
5534 (char *) "self", NULL
5535 };
5536
5537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5539 if (SWIG_arg_fail(1)) SWIG_fail;
5540 {
5541 PyThreadState* __tstate = wxPyBeginAllowThreads();
5542 result = (int)((wxRect const *)arg1)->GetBottom();
5543
5544 wxPyEndAllowThreads(__tstate);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 {
5548 resultobj = SWIG_From_int((int)(result));
5549 }
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5557 PyObject *resultobj;
5558 wxRect *arg1 = (wxRect *) 0 ;
5559 int result;
5560 PyObject * obj0 = 0 ;
5561 char *kwnames[] = {
5562 (char *) "self", NULL
5563 };
5564
5565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5567 if (SWIG_arg_fail(1)) SWIG_fail;
5568 {
5569 PyThreadState* __tstate = wxPyBeginAllowThreads();
5570 result = (int)((wxRect const *)arg1)->GetRight();
5571
5572 wxPyEndAllowThreads(__tstate);
5573 if (PyErr_Occurred()) SWIG_fail;
5574 }
5575 {
5576 resultobj = SWIG_From_int((int)(result));
5577 }
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj;
5586 wxRect *arg1 = (wxRect *) 0 ;
5587 int arg2 ;
5588 PyObject * obj0 = 0 ;
5589 PyObject * obj1 = 0 ;
5590 char *kwnames[] = {
5591 (char *) "self",(char *) "left", NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5596 if (SWIG_arg_fail(1)) SWIG_fail;
5597 {
5598 arg2 = (int)(SWIG_As_int(obj1));
5599 if (SWIG_arg_fail(2)) SWIG_fail;
5600 }
5601 {
5602 PyThreadState* __tstate = wxPyBeginAllowThreads();
5603 (arg1)->SetLeft(arg2);
5604
5605 wxPyEndAllowThreads(__tstate);
5606 if (PyErr_Occurred()) SWIG_fail;
5607 }
5608 Py_INCREF(Py_None); resultobj = Py_None;
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5616 PyObject *resultobj;
5617 wxRect *arg1 = (wxRect *) 0 ;
5618 int arg2 ;
5619 PyObject * obj0 = 0 ;
5620 PyObject * obj1 = 0 ;
5621 char *kwnames[] = {
5622 (char *) "self",(char *) "right", NULL
5623 };
5624
5625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5627 if (SWIG_arg_fail(1)) SWIG_fail;
5628 {
5629 arg2 = (int)(SWIG_As_int(obj1));
5630 if (SWIG_arg_fail(2)) SWIG_fail;
5631 }
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 (arg1)->SetRight(arg2);
5635
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 Py_INCREF(Py_None); resultobj = Py_None;
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj;
5648 wxRect *arg1 = (wxRect *) 0 ;
5649 int arg2 ;
5650 PyObject * obj0 = 0 ;
5651 PyObject * obj1 = 0 ;
5652 char *kwnames[] = {
5653 (char *) "self",(char *) "top", NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5658 if (SWIG_arg_fail(1)) SWIG_fail;
5659 {
5660 arg2 = (int)(SWIG_As_int(obj1));
5661 if (SWIG_arg_fail(2)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 (arg1)->SetTop(arg2);
5666
5667 wxPyEndAllowThreads(__tstate);
5668 if (PyErr_Occurred()) SWIG_fail;
5669 }
5670 Py_INCREF(Py_None); resultobj = Py_None;
5671 return resultobj;
5672 fail:
5673 return NULL;
5674 }
5675
5676
5677 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5678 PyObject *resultobj;
5679 wxRect *arg1 = (wxRect *) 0 ;
5680 int arg2 ;
5681 PyObject * obj0 = 0 ;
5682 PyObject * obj1 = 0 ;
5683 char *kwnames[] = {
5684 (char *) "self",(char *) "bottom", NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 {
5691 arg2 = (int)(SWIG_As_int(obj1));
5692 if (SWIG_arg_fail(2)) SWIG_fail;
5693 }
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 (arg1)->SetBottom(arg2);
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 Py_INCREF(Py_None); resultobj = Py_None;
5702 return resultobj;
5703 fail:
5704 return NULL;
5705 }
5706
5707
5708 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5709 PyObject *resultobj;
5710 wxRect *arg1 = (wxRect *) 0 ;
5711 int arg2 ;
5712 int arg3 ;
5713 wxRect *result;
5714 PyObject * obj0 = 0 ;
5715 PyObject * obj1 = 0 ;
5716 PyObject * obj2 = 0 ;
5717 char *kwnames[] = {
5718 (char *) "self",(char *) "dx",(char *) "dy", NULL
5719 };
5720
5721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5723 if (SWIG_arg_fail(1)) SWIG_fail;
5724 {
5725 arg2 = (int)(SWIG_As_int(obj1));
5726 if (SWIG_arg_fail(2)) SWIG_fail;
5727 }
5728 {
5729 arg3 = (int)(SWIG_As_int(obj2));
5730 if (SWIG_arg_fail(3)) SWIG_fail;
5731 }
5732 {
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 {
5735 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5736 result = (wxRect *) &_result_ref;
5737 }
5738
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj;
5751 wxRect *arg1 = (wxRect *) 0 ;
5752 int arg2 ;
5753 int arg3 ;
5754 wxRect *result;
5755 PyObject * obj0 = 0 ;
5756 PyObject * obj1 = 0 ;
5757 PyObject * obj2 = 0 ;
5758 char *kwnames[] = {
5759 (char *) "self",(char *) "dx",(char *) "dy", NULL
5760 };
5761
5762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5764 if (SWIG_arg_fail(1)) SWIG_fail;
5765 {
5766 arg2 = (int)(SWIG_As_int(obj1));
5767 if (SWIG_arg_fail(2)) SWIG_fail;
5768 }
5769 {
5770 arg3 = (int)(SWIG_As_int(obj2));
5771 if (SWIG_arg_fail(3)) SWIG_fail;
5772 }
5773 {
5774 PyThreadState* __tstate = wxPyBeginAllowThreads();
5775 {
5776 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5777 result = (wxRect *) &_result_ref;
5778 }
5779
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj;
5792 wxRect *arg1 = (wxRect *) 0 ;
5793 int arg2 ;
5794 int arg3 ;
5795 PyObject * obj0 = 0 ;
5796 PyObject * obj1 = 0 ;
5797 PyObject * obj2 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "self",(char *) "dx",(char *) "dy", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5804 if (SWIG_arg_fail(1)) SWIG_fail;
5805 {
5806 arg2 = (int)(SWIG_As_int(obj1));
5807 if (SWIG_arg_fail(2)) SWIG_fail;
5808 }
5809 {
5810 arg3 = (int)(SWIG_As_int(obj2));
5811 if (SWIG_arg_fail(3)) SWIG_fail;
5812 }
5813 {
5814 PyThreadState* __tstate = wxPyBeginAllowThreads();
5815 (arg1)->Offset(arg2,arg3);
5816
5817 wxPyEndAllowThreads(__tstate);
5818 if (PyErr_Occurred()) SWIG_fail;
5819 }
5820 Py_INCREF(Py_None); resultobj = Py_None;
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj;
5829 wxRect *arg1 = (wxRect *) 0 ;
5830 wxPoint *arg2 = 0 ;
5831 wxPoint temp2 ;
5832 PyObject * obj0 = 0 ;
5833 PyObject * obj1 = 0 ;
5834 char *kwnames[] = {
5835 (char *) "self",(char *) "pt", NULL
5836 };
5837
5838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5840 if (SWIG_arg_fail(1)) SWIG_fail;
5841 {
5842 arg2 = &temp2;
5843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5844 }
5845 {
5846 PyThreadState* __tstate = wxPyBeginAllowThreads();
5847 (arg1)->Offset((wxPoint const &)*arg2);
5848
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 Py_INCREF(Py_None); resultobj = Py_None;
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj;
5861 wxRect *arg1 = (wxRect *) 0 ;
5862 wxRect *arg2 = 0 ;
5863 wxRect result;
5864 wxRect temp2 ;
5865 PyObject * obj0 = 0 ;
5866 PyObject * obj1 = 0 ;
5867 char *kwnames[] = {
5868 (char *) "self",(char *) "rect", NULL
5869 };
5870
5871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5873 if (SWIG_arg_fail(1)) SWIG_fail;
5874 {
5875 arg2 = &temp2;
5876 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5877 }
5878 {
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 result = (arg1)->Intersect((wxRect const &)*arg2);
5881
5882 wxPyEndAllowThreads(__tstate);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 {
5886 wxRect * resultptr;
5887 resultptr = new wxRect((wxRect &)(result));
5888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5889 }
5890 return resultobj;
5891 fail:
5892 return NULL;
5893 }
5894
5895
5896 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5897 PyObject *resultobj;
5898 wxRect *arg1 = (wxRect *) 0 ;
5899 wxRect *arg2 = 0 ;
5900 wxRect result;
5901 wxRect temp2 ;
5902 PyObject * obj0 = 0 ;
5903 PyObject * obj1 = 0 ;
5904 char *kwnames[] = {
5905 (char *) "self",(char *) "rect", NULL
5906 };
5907
5908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5910 if (SWIG_arg_fail(1)) SWIG_fail;
5911 {
5912 arg2 = &temp2;
5913 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5914 }
5915 {
5916 PyThreadState* __tstate = wxPyBeginAllowThreads();
5917 result = (arg1)->Union((wxRect const &)*arg2);
5918
5919 wxPyEndAllowThreads(__tstate);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 {
5923 wxRect * resultptr;
5924 resultptr = new wxRect((wxRect &)(result));
5925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5926 }
5927 return resultobj;
5928 fail:
5929 return NULL;
5930 }
5931
5932
5933 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5934 PyObject *resultobj;
5935 wxRect *arg1 = (wxRect *) 0 ;
5936 wxRect *arg2 = 0 ;
5937 wxRect result;
5938 wxRect temp2 ;
5939 PyObject * obj0 = 0 ;
5940 PyObject * obj1 = 0 ;
5941 char *kwnames[] = {
5942 (char *) "self",(char *) "rect", NULL
5943 };
5944
5945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5947 if (SWIG_arg_fail(1)) SWIG_fail;
5948 {
5949 arg2 = &temp2;
5950 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5951 }
5952 {
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5955
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 {
5960 wxRect * resultptr;
5961 resultptr = new wxRect((wxRect &)(result));
5962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5963 }
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5971 PyObject *resultobj;
5972 wxRect *arg1 = (wxRect *) 0 ;
5973 wxRect *arg2 = 0 ;
5974 wxRect *result;
5975 wxRect temp2 ;
5976 PyObject * obj0 = 0 ;
5977 PyObject * obj1 = 0 ;
5978 char *kwnames[] = {
5979 (char *) "self",(char *) "rect", NULL
5980 };
5981
5982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5984 if (SWIG_arg_fail(1)) SWIG_fail;
5985 {
5986 arg2 = &temp2;
5987 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5988 }
5989 {
5990 PyThreadState* __tstate = wxPyBeginAllowThreads();
5991 {
5992 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5993 result = (wxRect *) &_result_ref;
5994 }
5995
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6000 return resultobj;
6001 fail:
6002 return NULL;
6003 }
6004
6005
6006 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj;
6008 wxRect *arg1 = (wxRect *) 0 ;
6009 wxRect *arg2 = 0 ;
6010 bool result;
6011 wxRect temp2 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 char *kwnames[] = {
6015 (char *) "self",(char *) "rect", NULL
6016 };
6017
6018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6020 if (SWIG_arg_fail(1)) SWIG_fail;
6021 {
6022 arg2 = &temp2;
6023 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6024 }
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 {
6033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6034 }
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj;
6043 wxRect *arg1 = (wxRect *) 0 ;
6044 wxRect *arg2 = 0 ;
6045 bool result;
6046 wxRect temp2 ;
6047 PyObject * obj0 = 0 ;
6048 PyObject * obj1 = 0 ;
6049 char *kwnames[] = {
6050 (char *) "self",(char *) "rect", NULL
6051 };
6052
6053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6055 if (SWIG_arg_fail(1)) SWIG_fail;
6056 {
6057 arg2 = &temp2;
6058 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6059 }
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj;
6078 wxRect *arg1 = (wxRect *) 0 ;
6079 int arg2 ;
6080 int arg3 ;
6081 bool result;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 PyObject * obj2 = 0 ;
6085 char *kwnames[] = {
6086 (char *) "self",(char *) "x",(char *) "y", NULL
6087 };
6088
6089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6091 if (SWIG_arg_fail(1)) SWIG_fail;
6092 {
6093 arg2 = (int)(SWIG_As_int(obj1));
6094 if (SWIG_arg_fail(2)) SWIG_fail;
6095 }
6096 {
6097 arg3 = (int)(SWIG_As_int(obj2));
6098 if (SWIG_arg_fail(3)) SWIG_fail;
6099 }
6100 {
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6103
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6109 }
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 wxRect *arg1 = (wxRect *) 0 ;
6119 wxPoint *arg2 = 0 ;
6120 bool result;
6121 wxPoint temp2 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char *kwnames[] = {
6125 (char *) "self",(char *) "pt", NULL
6126 };
6127
6128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6130 if (SWIG_arg_fail(1)) SWIG_fail;
6131 {
6132 arg2 = &temp2;
6133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6134 }
6135 {
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6138
6139 wxPyEndAllowThreads(__tstate);
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 {
6143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6144 }
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj;
6153 wxRect *arg1 = (wxRect *) 0 ;
6154 wxRect *arg2 = 0 ;
6155 bool result;
6156 wxRect temp2 ;
6157 PyObject * obj0 = 0 ;
6158 PyObject * obj1 = 0 ;
6159 char *kwnames[] = {
6160 (char *) "self",(char *) "rect", NULL
6161 };
6162
6163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6165 if (SWIG_arg_fail(1)) SWIG_fail;
6166 {
6167 arg2 = &temp2;
6168 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6169 }
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 {
6178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6179 }
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj;
6188 wxRect *arg1 = (wxRect *) 0 ;
6189 int arg2 ;
6190 PyObject * obj0 = 0 ;
6191 PyObject * obj1 = 0 ;
6192 char *kwnames[] = {
6193 (char *) "self",(char *) "x", NULL
6194 };
6195
6196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6198 if (SWIG_arg_fail(1)) SWIG_fail;
6199 {
6200 arg2 = (int)(SWIG_As_int(obj1));
6201 if (SWIG_arg_fail(2)) SWIG_fail;
6202 }
6203 if (arg1) (arg1)->x = arg2;
6204
6205 Py_INCREF(Py_None); resultobj = Py_None;
6206 return resultobj;
6207 fail:
6208 return NULL;
6209 }
6210
6211
6212 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6213 PyObject *resultobj;
6214 wxRect *arg1 = (wxRect *) 0 ;
6215 int result;
6216 PyObject * obj0 = 0 ;
6217 char *kwnames[] = {
6218 (char *) "self", NULL
6219 };
6220
6221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6223 if (SWIG_arg_fail(1)) SWIG_fail;
6224 result = (int) ((arg1)->x);
6225
6226 {
6227 resultobj = SWIG_From_int((int)(result));
6228 }
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 int arg2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "self",(char *) "y", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6247 if (SWIG_arg_fail(1)) SWIG_fail;
6248 {
6249 arg2 = (int)(SWIG_As_int(obj1));
6250 if (SWIG_arg_fail(2)) SWIG_fail;
6251 }
6252 if (arg1) (arg1)->y = arg2;
6253
6254 Py_INCREF(Py_None); resultobj = Py_None;
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj;
6263 wxRect *arg1 = (wxRect *) 0 ;
6264 int result;
6265 PyObject * obj0 = 0 ;
6266 char *kwnames[] = {
6267 (char *) "self", NULL
6268 };
6269
6270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6272 if (SWIG_arg_fail(1)) SWIG_fail;
6273 result = (int) ((arg1)->y);
6274
6275 {
6276 resultobj = SWIG_From_int((int)(result));
6277 }
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj;
6286 wxRect *arg1 = (wxRect *) 0 ;
6287 int arg2 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 char *kwnames[] = {
6291 (char *) "self",(char *) "width", NULL
6292 };
6293
6294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6296 if (SWIG_arg_fail(1)) SWIG_fail;
6297 {
6298 arg2 = (int)(SWIG_As_int(obj1));
6299 if (SWIG_arg_fail(2)) SWIG_fail;
6300 }
6301 if (arg1) (arg1)->width = arg2;
6302
6303 Py_INCREF(Py_None); resultobj = Py_None;
6304 return resultobj;
6305 fail:
6306 return NULL;
6307 }
6308
6309
6310 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6311 PyObject *resultobj;
6312 wxRect *arg1 = (wxRect *) 0 ;
6313 int result;
6314 PyObject * obj0 = 0 ;
6315 char *kwnames[] = {
6316 (char *) "self", NULL
6317 };
6318
6319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6321 if (SWIG_arg_fail(1)) SWIG_fail;
6322 result = (int) ((arg1)->width);
6323
6324 {
6325 resultobj = SWIG_From_int((int)(result));
6326 }
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6334 PyObject *resultobj;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int arg2 ;
6337 PyObject * obj0 = 0 ;
6338 PyObject * obj1 = 0 ;
6339 char *kwnames[] = {
6340 (char *) "self",(char *) "height", NULL
6341 };
6342
6343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 {
6347 arg2 = (int)(SWIG_As_int(obj1));
6348 if (SWIG_arg_fail(2)) SWIG_fail;
6349 }
6350 if (arg1) (arg1)->height = arg2;
6351
6352 Py_INCREF(Py_None); resultobj = Py_None;
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 int result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6370 if (SWIG_arg_fail(1)) SWIG_fail;
6371 result = (int) ((arg1)->height);
6372
6373 {
6374 resultobj = SWIG_From_int((int)(result));
6375 }
6376 return resultobj;
6377 fail:
6378 return NULL;
6379 }
6380
6381
6382 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6383 PyObject *resultobj;
6384 wxRect *arg1 = (wxRect *) 0 ;
6385 int arg2 = (int) 0 ;
6386 int arg3 = (int) 0 ;
6387 int arg4 = (int) 0 ;
6388 int arg5 = (int) 0 ;
6389 PyObject * obj0 = 0 ;
6390 PyObject * obj1 = 0 ;
6391 PyObject * obj2 = 0 ;
6392 PyObject * obj3 = 0 ;
6393 PyObject * obj4 = 0 ;
6394 char *kwnames[] = {
6395 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6396 };
6397
6398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6400 if (SWIG_arg_fail(1)) SWIG_fail;
6401 if (obj1) {
6402 {
6403 arg2 = (int)(SWIG_As_int(obj1));
6404 if (SWIG_arg_fail(2)) SWIG_fail;
6405 }
6406 }
6407 if (obj2) {
6408 {
6409 arg3 = (int)(SWIG_As_int(obj2));
6410 if (SWIG_arg_fail(3)) SWIG_fail;
6411 }
6412 }
6413 if (obj3) {
6414 {
6415 arg4 = (int)(SWIG_As_int(obj3));
6416 if (SWIG_arg_fail(4)) SWIG_fail;
6417 }
6418 }
6419 if (obj4) {
6420 {
6421 arg5 = (int)(SWIG_As_int(obj4));
6422 if (SWIG_arg_fail(5)) SWIG_fail;
6423 }
6424 }
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6428
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 Py_INCREF(Py_None); resultobj = Py_None;
6433 return resultobj;
6434 fail:
6435 return NULL;
6436 }
6437
6438
6439 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6440 PyObject *resultobj;
6441 wxRect *arg1 = (wxRect *) 0 ;
6442 PyObject *result;
6443 PyObject * obj0 = 0 ;
6444 char *kwnames[] = {
6445 (char *) "self", NULL
6446 };
6447
6448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6450 if (SWIG_arg_fail(1)) SWIG_fail;
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (PyObject *)wxRect_Get(arg1);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = result;
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6466 PyObject *obj;
6467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6468 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6469 Py_INCREF(obj);
6470 return Py_BuildValue((char *)"");
6471 }
6472 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxRect *arg1 = (wxRect *) 0 ;
6475 wxRect *arg2 = (wxRect *) 0 ;
6476 PyObject *result;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "r1",(char *) "r2", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6485 if (SWIG_arg_fail(1)) SWIG_fail;
6486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6487 if (SWIG_arg_fail(2)) SWIG_fail;
6488 {
6489 if (!wxPyCheckForApp()) SWIG_fail;
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (PyObject *)wxIntersectRect(arg1,arg2);
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = result;
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 double arg1 = (double) 0.0 ;
6506 double arg2 = (double) 0.0 ;
6507 wxPoint2D *result;
6508 PyObject * obj0 = 0 ;
6509 PyObject * obj1 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "x",(char *) "y", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6515 if (obj0) {
6516 {
6517 arg1 = (double)(SWIG_As_double(obj0));
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 }
6520 }
6521 if (obj1) {
6522 {
6523 arg2 = (double)(SWIG_As_double(obj1));
6524 if (SWIG_arg_fail(2)) SWIG_fail;
6525 }
6526 }
6527 {
6528 PyThreadState* __tstate = wxPyBeginAllowThreads();
6529 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6530
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6542 PyObject *resultobj;
6543 wxPoint2D *arg1 = 0 ;
6544 wxPoint2D *result;
6545 wxPoint2D temp1 ;
6546 PyObject * obj0 = 0 ;
6547 char *kwnames[] = {
6548 (char *) "pt", NULL
6549 };
6550
6551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6552 {
6553 arg1 = &temp1;
6554 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6555 }
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6559
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj;
6572 wxPoint *arg1 = 0 ;
6573 wxPoint2D *result;
6574 wxPoint temp1 ;
6575 PyObject * obj0 = 0 ;
6576 char *kwnames[] = {
6577 (char *) "pt", NULL
6578 };
6579
6580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6581 {
6582 arg1 = &temp1;
6583 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6584 }
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6588
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj;
6601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6602 int *arg2 = (int *) 0 ;
6603 int *arg3 = (int *) 0 ;
6604 int temp2 ;
6605 int res2 = 0 ;
6606 int temp3 ;
6607 int res3 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 char *kwnames[] = {
6610 (char *) "self", NULL
6611 };
6612
6613 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6614 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 Py_INCREF(Py_None); resultobj = Py_None;
6626 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6627 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6628 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6629 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj;
6638 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6639 int *arg2 = (int *) 0 ;
6640 int *arg3 = (int *) 0 ;
6641 int temp2 ;
6642 int res2 = 0 ;
6643 int temp3 ;
6644 int res3 = 0 ;
6645 PyObject * obj0 = 0 ;
6646 char *kwnames[] = {
6647 (char *) "self", NULL
6648 };
6649
6650 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6651 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6654 if (SWIG_arg_fail(1)) SWIG_fail;
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6658
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 Py_INCREF(Py_None); resultobj = Py_None;
6663 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6664 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6665 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6666 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6674 PyObject *resultobj;
6675 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6676 double result;
6677 PyObject * obj0 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self", NULL
6680 };
6681
6682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(1)) SWIG_fail;
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6688
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 {
6693 resultobj = SWIG_From_double((double)(result));
6694 }
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6702 PyObject *resultobj;
6703 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6704 double result;
6705 PyObject * obj0 = 0 ;
6706 char *kwnames[] = {
6707 (char *) "self", NULL
6708 };
6709
6710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6712 if (SWIG_arg_fail(1)) SWIG_fail;
6713 {
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6716
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 {
6721 resultobj = SWIG_From_double((double)(result));
6722 }
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6730 PyObject *resultobj;
6731 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6732 double arg2 ;
6733 PyObject * obj0 = 0 ;
6734 PyObject * obj1 = 0 ;
6735 char *kwnames[] = {
6736 (char *) "self",(char *) "length", NULL
6737 };
6738
6739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6741 if (SWIG_arg_fail(1)) SWIG_fail;
6742 {
6743 arg2 = (double)(SWIG_As_double(obj1));
6744 if (SWIG_arg_fail(2)) SWIG_fail;
6745 }
6746 {
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 (arg1)->SetVectorLength(arg2);
6749
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 Py_INCREF(Py_None); resultobj = Py_None;
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6761 PyObject *resultobj;
6762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6763 double arg2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "self",(char *) "degrees", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6772 if (SWIG_arg_fail(1)) SWIG_fail;
6773 {
6774 arg2 = (double)(SWIG_As_double(obj1));
6775 if (SWIG_arg_fail(2)) SWIG_fail;
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 (arg1)->SetVectorAngle(arg2);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 Py_INCREF(Py_None); resultobj = Py_None;
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj;
6793 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6794 wxPoint2D *arg2 = 0 ;
6795 double result;
6796 wxPoint2D temp2 ;
6797 PyObject * obj0 = 0 ;
6798 PyObject * obj1 = 0 ;
6799 char *kwnames[] = {
6800 (char *) "self",(char *) "pt", NULL
6801 };
6802
6803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6805 if (SWIG_arg_fail(1)) SWIG_fail;
6806 {
6807 arg2 = &temp2;
6808 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6809 }
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 {
6818 resultobj = SWIG_From_double((double)(result));
6819 }
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6827 PyObject *resultobj;
6828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6829 wxPoint2D *arg2 = 0 ;
6830 double result;
6831 wxPoint2D temp2 ;
6832 PyObject * obj0 = 0 ;
6833 PyObject * obj1 = 0 ;
6834 char *kwnames[] = {
6835 (char *) "self",(char *) "pt", NULL
6836 };
6837
6838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6840 if (SWIG_arg_fail(1)) SWIG_fail;
6841 {
6842 arg2 = &temp2;
6843 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6844 }
6845 {
6846 PyThreadState* __tstate = wxPyBeginAllowThreads();
6847 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6848
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 {
6853 resultobj = SWIG_From_double((double)(result));
6854 }
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj;
6863 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6864 wxPoint2D *arg2 = 0 ;
6865 double result;
6866 wxPoint2D temp2 ;
6867 PyObject * obj0 = 0 ;
6868 PyObject * obj1 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "self",(char *) "vec", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 {
6877 arg2 = &temp2;
6878 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6879 }
6880 {
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6883
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 {
6888 resultobj = SWIG_From_double((double)(result));
6889 }
6890 return resultobj;
6891 fail:
6892 return NULL;
6893 }
6894
6895
6896 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6897 PyObject *resultobj;
6898 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6899 wxPoint2D *arg2 = 0 ;
6900 double result;
6901 wxPoint2D temp2 ;
6902 PyObject * obj0 = 0 ;
6903 PyObject * obj1 = 0 ;
6904 char *kwnames[] = {
6905 (char *) "self",(char *) "vec", NULL
6906 };
6907
6908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6910 if (SWIG_arg_fail(1)) SWIG_fail;
6911 {
6912 arg2 = &temp2;
6913 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6914 }
6915 {
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6918
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 {
6923 resultobj = SWIG_From_double((double)(result));
6924 }
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6932 PyObject *resultobj;
6933 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6934 wxPoint2D result;
6935 PyObject * obj0 = 0 ;
6936 char *kwnames[] = {
6937 (char *) "self", NULL
6938 };
6939
6940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6942 if (SWIG_arg_fail(1)) SWIG_fail;
6943 {
6944 PyThreadState* __tstate = wxPyBeginAllowThreads();
6945 result = (arg1)->operator -();
6946
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 {
6951 wxPoint2D * resultptr;
6952 resultptr = new wxPoint2D((wxPoint2D &)(result));
6953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6964 wxPoint2D *arg2 = 0 ;
6965 wxPoint2D *result;
6966 wxPoint2D temp2 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char *kwnames[] = {
6970 (char *) "self",(char *) "pt", NULL
6971 };
6972
6973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6975 if (SWIG_arg_fail(1)) SWIG_fail;
6976 {
6977 arg2 = &temp2;
6978 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6979 }
6980 {
6981 PyThreadState* __tstate = wxPyBeginAllowThreads();
6982 {
6983 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6984 result = (wxPoint2D *) &_result_ref;
6985 }
6986
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6998 PyObject *resultobj;
6999 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7000 wxPoint2D *arg2 = 0 ;
7001 wxPoint2D *result;
7002 wxPoint2D temp2 ;
7003 PyObject * obj0 = 0 ;
7004 PyObject * obj1 = 0 ;
7005 char *kwnames[] = {
7006 (char *) "self",(char *) "pt", NULL
7007 };
7008
7009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7011 if (SWIG_arg_fail(1)) SWIG_fail;
7012 {
7013 arg2 = &temp2;
7014 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7015 }
7016 {
7017 PyThreadState* __tstate = wxPyBeginAllowThreads();
7018 {
7019 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7020 result = (wxPoint2D *) &_result_ref;
7021 }
7022
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj;
7035 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7036 wxPoint2D *arg2 = 0 ;
7037 wxPoint2D *result;
7038 wxPoint2D temp2 ;
7039 PyObject * obj0 = 0 ;
7040 PyObject * obj1 = 0 ;
7041 char *kwnames[] = {
7042 (char *) "self",(char *) "pt", NULL
7043 };
7044
7045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7047 if (SWIG_arg_fail(1)) SWIG_fail;
7048 {
7049 arg2 = &temp2;
7050 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7051 }
7052 {
7053 PyThreadState* __tstate = wxPyBeginAllowThreads();
7054 {
7055 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7056 result = (wxPoint2D *) &_result_ref;
7057 }
7058
7059 wxPyEndAllowThreads(__tstate);
7060 if (PyErr_Occurred()) SWIG_fail;
7061 }
7062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7063 return resultobj;
7064 fail:
7065 return NULL;
7066 }
7067
7068
7069 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7070 PyObject *resultobj;
7071 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7072 wxPoint2D *arg2 = 0 ;
7073 wxPoint2D *result;
7074 wxPoint2D temp2 ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 char *kwnames[] = {
7078 (char *) "self",(char *) "pt", NULL
7079 };
7080
7081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7083 if (SWIG_arg_fail(1)) SWIG_fail;
7084 {
7085 arg2 = &temp2;
7086 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7087 }
7088 {
7089 PyThreadState* __tstate = wxPyBeginAllowThreads();
7090 {
7091 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7092 result = (wxPoint2D *) &_result_ref;
7093 }
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj;
7107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7108 wxPoint2D *arg2 = 0 ;
7109 bool result;
7110 wxPoint2D temp2 ;
7111 PyObject * obj0 = 0 ;
7112 PyObject * obj1 = 0 ;
7113 char *kwnames[] = {
7114 (char *) "self",(char *) "pt", NULL
7115 };
7116
7117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7119 if (SWIG_arg_fail(1)) SWIG_fail;
7120 {
7121 arg2 = &temp2;
7122 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7123 }
7124 {
7125 PyThreadState* __tstate = wxPyBeginAllowThreads();
7126 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7127
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7133 }
7134 return resultobj;
7135 fail:
7136 return NULL;
7137 }
7138
7139
7140 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7141 PyObject *resultobj;
7142 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7143 wxPoint2D *arg2 = 0 ;
7144 bool result;
7145 wxPoint2D temp2 ;
7146 PyObject * obj0 = 0 ;
7147 PyObject * obj1 = 0 ;
7148 char *kwnames[] = {
7149 (char *) "self",(char *) "pt", NULL
7150 };
7151
7152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(1)) SWIG_fail;
7155 {
7156 arg2 = &temp2;
7157 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7158 }
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7162
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 {
7167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7168 }
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj;
7177 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7178 double arg2 ;
7179 PyObject * obj0 = 0 ;
7180 PyObject * obj1 = 0 ;
7181 char *kwnames[] = {
7182 (char *) "self",(char *) "m_x", NULL
7183 };
7184
7185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7187 if (SWIG_arg_fail(1)) SWIG_fail;
7188 {
7189 arg2 = (double)(SWIG_As_double(obj1));
7190 if (SWIG_arg_fail(2)) SWIG_fail;
7191 }
7192 if (arg1) (arg1)->m_x = arg2;
7193
7194 Py_INCREF(Py_None); resultobj = Py_None;
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj;
7203 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7204 double result;
7205 PyObject * obj0 = 0 ;
7206 char *kwnames[] = {
7207 (char *) "self", NULL
7208 };
7209
7210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7212 if (SWIG_arg_fail(1)) SWIG_fail;
7213 result = (double) ((arg1)->m_x);
7214
7215 {
7216 resultobj = SWIG_From_double((double)(result));
7217 }
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj;
7226 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7227 double arg2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self",(char *) "m_y", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 {
7238 arg2 = (double)(SWIG_As_double(obj1));
7239 if (SWIG_arg_fail(2)) SWIG_fail;
7240 }
7241 if (arg1) (arg1)->m_y = arg2;
7242
7243 Py_INCREF(Py_None); resultobj = Py_None;
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7251 PyObject *resultobj;
7252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7253 double result;
7254 PyObject * obj0 = 0 ;
7255 char *kwnames[] = {
7256 (char *) "self", NULL
7257 };
7258
7259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7261 if (SWIG_arg_fail(1)) SWIG_fail;
7262 result = (double) ((arg1)->m_y);
7263
7264 {
7265 resultobj = SWIG_From_double((double)(result));
7266 }
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj;
7275 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7276 double arg2 = (double) 0 ;
7277 double arg3 = (double) 0 ;
7278 PyObject * obj0 = 0 ;
7279 PyObject * obj1 = 0 ;
7280 PyObject * obj2 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self",(char *) "x",(char *) "y", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 if (obj1) {
7289 {
7290 arg2 = (double)(SWIG_As_double(obj1));
7291 if (SWIG_arg_fail(2)) SWIG_fail;
7292 }
7293 }
7294 if (obj2) {
7295 {
7296 arg3 = (double)(SWIG_As_double(obj2));
7297 if (SWIG_arg_fail(3)) SWIG_fail;
7298 }
7299 }
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 wxPoint2D_Set(arg1,arg2,arg3);
7303
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 Py_INCREF(Py_None); resultobj = Py_None;
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj;
7316 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7317 PyObject *result;
7318 PyObject * obj0 = 0 ;
7319 char *kwnames[] = {
7320 (char *) "self", NULL
7321 };
7322
7323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7325 if (SWIG_arg_fail(1)) SWIG_fail;
7326 {
7327 PyThreadState* __tstate = wxPyBeginAllowThreads();
7328 result = (PyObject *)wxPoint2D_Get(arg1);
7329
7330 wxPyEndAllowThreads(__tstate);
7331 if (PyErr_Occurred()) SWIG_fail;
7332 }
7333 resultobj = result;
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7341 PyObject *obj;
7342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7343 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7344 Py_INCREF(obj);
7345 return Py_BuildValue((char *)"");
7346 }
7347 static int _wrap_DefaultPosition_set(PyObject *) {
7348 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7349 return 1;
7350 }
7351
7352
7353 static PyObject *_wrap_DefaultPosition_get(void) {
7354 PyObject *pyobj;
7355
7356 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7357 return pyobj;
7358 }
7359
7360
7361 static int _wrap_DefaultSize_set(PyObject *) {
7362 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7363 return 1;
7364 }
7365
7366
7367 static PyObject *_wrap_DefaultSize_get(void) {
7368 PyObject *pyobj;
7369
7370 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7371 return pyobj;
7372 }
7373
7374
7375 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7376 PyObject *resultobj;
7377 PyObject *arg1 = (PyObject *) 0 ;
7378 wxPyInputStream *result;
7379 PyObject * obj0 = 0 ;
7380 char *kwnames[] = {
7381 (char *) "p", NULL
7382 };
7383
7384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7385 arg1 = obj0;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7389
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj;
7402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7403 PyObject * obj0 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 delete arg1;
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 Py_INCREF(Py_None); resultobj = Py_None;
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7428 PyObject * obj0 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->close();
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 Py_INCREF(Py_None); resultobj = Py_None;
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj;
7452 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7453 PyObject * obj0 = 0 ;
7454 char *kwnames[] = {
7455 (char *) "self", NULL
7456 };
7457
7458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(1)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 (arg1)->flush();
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 Py_INCREF(Py_None); resultobj = Py_None;
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj;
7477 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7478 bool result;
7479 PyObject * obj0 = 0 ;
7480 char *kwnames[] = {
7481 (char *) "self", NULL
7482 };
7483
7484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7486 if (SWIG_arg_fail(1)) SWIG_fail;
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)(arg1)->eof();
7490
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 {
7495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7496 }
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj;
7505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7506 int arg2 = (int) -1 ;
7507 PyObject *result;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char *kwnames[] = {
7511 (char *) "self",(char *) "size", NULL
7512 };
7513
7514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7516 if (SWIG_arg_fail(1)) SWIG_fail;
7517 if (obj1) {
7518 {
7519 arg2 = (int)(SWIG_As_int(obj1));
7520 if (SWIG_arg_fail(2)) SWIG_fail;
7521 }
7522 }
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (PyObject *)(arg1)->read(arg2);
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = result;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7540 int arg2 = (int) -1 ;
7541 PyObject *result;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 char *kwnames[] = {
7545 (char *) "self",(char *) "size", NULL
7546 };
7547
7548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7550 if (SWIG_arg_fail(1)) SWIG_fail;
7551 if (obj1) {
7552 {
7553 arg2 = (int)(SWIG_As_int(obj1));
7554 if (SWIG_arg_fail(2)) SWIG_fail;
7555 }
7556 }
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (PyObject *)(arg1)->readline(arg2);
7560
7561 wxPyEndAllowThreads(__tstate);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 resultobj = result;
7565 return resultobj;
7566 fail:
7567 return NULL;
7568 }
7569
7570
7571 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7572 PyObject *resultobj;
7573 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7574 int arg2 = (int) -1 ;
7575 PyObject *result;
7576 PyObject * obj0 = 0 ;
7577 PyObject * obj1 = 0 ;
7578 char *kwnames[] = {
7579 (char *) "self",(char *) "sizehint", NULL
7580 };
7581
7582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7584 if (SWIG_arg_fail(1)) SWIG_fail;
7585 if (obj1) {
7586 {
7587 arg2 = (int)(SWIG_As_int(obj1));
7588 if (SWIG_arg_fail(2)) SWIG_fail;
7589 }
7590 }
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (PyObject *)(arg1)->readlines(arg2);
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 resultobj = result;
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7608 int arg2 ;
7609 int arg3 = (int) 0 ;
7610 PyObject * obj0 = 0 ;
7611 PyObject * obj1 = 0 ;
7612 PyObject * obj2 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self",(char *) "offset",(char *) "whence", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 arg2 = (int)(SWIG_As_int(obj1));
7622 if (SWIG_arg_fail(2)) SWIG_fail;
7623 }
7624 if (obj2) {
7625 {
7626 arg3 = (int)(SWIG_As_int(obj2));
7627 if (SWIG_arg_fail(3)) SWIG_fail;
7628 }
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->seek(arg2,arg3);
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 Py_INCREF(Py_None); resultobj = Py_None;
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj;
7646 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7647 int result;
7648 PyObject * obj0 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "self", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7655 if (SWIG_arg_fail(1)) SWIG_fail;
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (int)(arg1)->tell();
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 resultobj = SWIG_From_int((int)(result));
7665 }
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj;
7674 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7675 char result;
7676 PyObject * obj0 = 0 ;
7677 char *kwnames[] = {
7678 (char *) "self", NULL
7679 };
7680
7681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7683 if (SWIG_arg_fail(1)) SWIG_fail;
7684 {
7685 PyThreadState* __tstate = wxPyBeginAllowThreads();
7686 result = (char)(arg1)->Peek();
7687
7688 wxPyEndAllowThreads(__tstate);
7689 if (PyErr_Occurred()) SWIG_fail;
7690 }
7691 {
7692 resultobj = SWIG_From_char((char)(result));
7693 }
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj;
7702 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7703 char result;
7704 PyObject * obj0 = 0 ;
7705 char *kwnames[] = {
7706 (char *) "self", NULL
7707 };
7708
7709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7711 if (SWIG_arg_fail(1)) SWIG_fail;
7712 {
7713 PyThreadState* __tstate = wxPyBeginAllowThreads();
7714 result = (char)(arg1)->GetC();
7715
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 {
7720 resultobj = SWIG_From_char((char)(result));
7721 }
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7731 size_t result;
7732 PyObject * obj0 = 0 ;
7733 char *kwnames[] = {
7734 (char *) "self", NULL
7735 };
7736
7737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7739 if (SWIG_arg_fail(1)) SWIG_fail;
7740 {
7741 PyThreadState* __tstate = wxPyBeginAllowThreads();
7742 result = (size_t)(arg1)->LastRead();
7743
7744 wxPyEndAllowThreads(__tstate);
7745 if (PyErr_Occurred()) SWIG_fail;
7746 }
7747 {
7748 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7749 }
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj;
7758 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7759 bool result;
7760 PyObject * obj0 = 0 ;
7761 char *kwnames[] = {
7762 (char *) "self", NULL
7763 };
7764
7765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7767 if (SWIG_arg_fail(1)) SWIG_fail;
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 result = (bool)(arg1)->CanRead();
7771
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 {
7776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777 }
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj;
7786 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7787 bool result;
7788 PyObject * obj0 = 0 ;
7789 char *kwnames[] = {
7790 (char *) "self", NULL
7791 };
7792
7793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7795 if (SWIG_arg_fail(1)) SWIG_fail;
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (bool)(arg1)->Eof();
7799
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 {
7804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7805 }
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj;
7814 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7815 char arg2 ;
7816 bool result;
7817 PyObject * obj0 = 0 ;
7818 PyObject * obj1 = 0 ;
7819 char *kwnames[] = {
7820 (char *) "self",(char *) "c", NULL
7821 };
7822
7823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7825 if (SWIG_arg_fail(1)) SWIG_fail;
7826 {
7827 arg2 = (char)(SWIG_As_char(obj1));
7828 if (SWIG_arg_fail(2)) SWIG_fail;
7829 }
7830 {
7831 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 result = (bool)(arg1)->Ungetch(arg2);
7833
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj;
7848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7849 long arg2 ;
7850 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7851 long result;
7852 PyObject * obj0 = 0 ;
7853 PyObject * obj1 = 0 ;
7854 PyObject * obj2 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "self",(char *) "pos",(char *) "mode", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 {
7863 arg2 = (long)(SWIG_As_long(obj1));
7864 if (SWIG_arg_fail(2)) SWIG_fail;
7865 }
7866 if (obj2) {
7867 {
7868 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7869 if (SWIG_arg_fail(3)) SWIG_fail;
7870 }
7871 }
7872 {
7873 PyThreadState* __tstate = wxPyBeginAllowThreads();
7874 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7875
7876 wxPyEndAllowThreads(__tstate);
7877 if (PyErr_Occurred()) SWIG_fail;
7878 }
7879 {
7880 resultobj = SWIG_From_long((long)(result));
7881 }
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj;
7890 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7891 long result;
7892 PyObject * obj0 = 0 ;
7893 char *kwnames[] = {
7894 (char *) "self", NULL
7895 };
7896
7897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7899 if (SWIG_arg_fail(1)) SWIG_fail;
7900 {
7901 PyThreadState* __tstate = wxPyBeginAllowThreads();
7902 result = (long)(arg1)->TellI();
7903
7904 wxPyEndAllowThreads(__tstate);
7905 if (PyErr_Occurred()) SWIG_fail;
7906 }
7907 {
7908 resultobj = SWIG_From_long((long)(result));
7909 }
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7917 PyObject *obj;
7918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7919 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7920 Py_INCREF(obj);
7921 return Py_BuildValue((char *)"");
7922 }
7923 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7926 PyObject *arg2 = (PyObject *) 0 ;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self",(char *) "obj", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 arg2 = obj1;
7937 {
7938 PyThreadState* __tstate = wxPyBeginAllowThreads();
7939 wxOutputStream_write(arg1,arg2);
7940
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 Py_INCREF(Py_None); resultobj = Py_None;
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7952 PyObject *obj;
7953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7954 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7955 Py_INCREF(obj);
7956 return Py_BuildValue((char *)"");
7957 }
7958 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj;
7960 wxInputStream *arg1 = (wxInputStream *) 0 ;
7961 wxString *arg2 = 0 ;
7962 wxString *arg3 = 0 ;
7963 wxString *arg4 = 0 ;
7964 wxDateTime arg5 ;
7965 wxFSFile *result;
7966 wxPyInputStream *temp1 ;
7967 bool temp2 = false ;
7968 bool temp3 = false ;
7969 bool temp4 = false ;
7970 PyObject * obj0 = 0 ;
7971 PyObject * obj1 = 0 ;
7972 PyObject * obj2 = 0 ;
7973 PyObject * obj3 = 0 ;
7974 PyObject * obj4 = 0 ;
7975 char *kwnames[] = {
7976 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7977 };
7978
7979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7980 {
7981 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7982 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7983 } else {
7984 PyErr_Clear(); // clear the failure of the wxPyConvert above
7985 arg1 = wxPyCBInputStream_create(obj0, true);
7986 if (arg1 == NULL) {
7987 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7988 SWIG_fail;
7989 }
7990 }
7991 }
7992 {
7993 arg2 = wxString_in_helper(obj1);
7994 if (arg2 == NULL) SWIG_fail;
7995 temp2 = true;
7996 }
7997 {
7998 arg3 = wxString_in_helper(obj2);
7999 if (arg3 == NULL) SWIG_fail;
8000 temp3 = true;
8001 }
8002 {
8003 arg4 = wxString_in_helper(obj3);
8004 if (arg4 == NULL) SWIG_fail;
8005 temp4 = true;
8006 }
8007 {
8008 wxDateTime * argp;
8009 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8010 if (SWIG_arg_fail(5)) SWIG_fail;
8011 if (argp == NULL) {
8012 SWIG_null_ref("wxDateTime");
8013 }
8014 if (SWIG_arg_fail(5)) SWIG_fail;
8015 arg5 = *argp;
8016 }
8017 {
8018 PyThreadState* __tstate = wxPyBeginAllowThreads();
8019 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8020
8021 wxPyEndAllowThreads(__tstate);
8022 if (PyErr_Occurred()) SWIG_fail;
8023 }
8024 {
8025 resultobj = wxPyMake_wxObject(result, 1);
8026 }
8027 {
8028 if (temp2)
8029 delete arg2;
8030 }
8031 {
8032 if (temp3)
8033 delete arg3;
8034 }
8035 {
8036 if (temp4)
8037 delete arg4;
8038 }
8039 return resultobj;
8040 fail:
8041 {
8042 if (temp2)
8043 delete arg2;
8044 }
8045 {
8046 if (temp3)
8047 delete arg3;
8048 }
8049 {
8050 if (temp4)
8051 delete arg4;
8052 }
8053 return NULL;
8054 }
8055
8056
8057 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj;
8059 wxFSFile *arg1 = (wxFSFile *) 0 ;
8060 PyObject * obj0 = 0 ;
8061 char *kwnames[] = {
8062 (char *) "self", NULL
8063 };
8064
8065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8067 if (SWIG_arg_fail(1)) SWIG_fail;
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 delete arg1;
8071
8072 wxPyEndAllowThreads(__tstate);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 Py_INCREF(Py_None); resultobj = Py_None;
8076 return resultobj;
8077 fail:
8078 return NULL;
8079 }
8080
8081
8082 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8083 PyObject *resultobj;
8084 wxFSFile *arg1 = (wxFSFile *) 0 ;
8085 wxInputStream *result;
8086 PyObject * obj0 = 0 ;
8087 char *kwnames[] = {
8088 (char *) "self", NULL
8089 };
8090
8091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8093 if (SWIG_arg_fail(1)) SWIG_fail;
8094 {
8095 PyThreadState* __tstate = wxPyBeginAllowThreads();
8096 result = (wxInputStream *)(arg1)->GetStream();
8097
8098 wxPyEndAllowThreads(__tstate);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 {
8102 wxPyInputStream * _ptr = NULL;
8103
8104 if (result) {
8105 _ptr = new wxPyInputStream(result);
8106 }
8107 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8108 }
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8116 PyObject *resultobj;
8117 wxFSFile *arg1 = (wxFSFile *) 0 ;
8118 wxString *result;
8119 PyObject * obj0 = 0 ;
8120 char *kwnames[] = {
8121 (char *) "self", NULL
8122 };
8123
8124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8126 if (SWIG_arg_fail(1)) SWIG_fail;
8127 {
8128 PyThreadState* __tstate = wxPyBeginAllowThreads();
8129 {
8130 wxString const &_result_ref = (arg1)->GetMimeType();
8131 result = (wxString *) &_result_ref;
8132 }
8133
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 {
8138 #if wxUSE_UNICODE
8139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8140 #else
8141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8142 #endif
8143 }
8144 return resultobj;
8145 fail:
8146 return NULL;
8147 }
8148
8149
8150 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8151 PyObject *resultobj;
8152 wxFSFile *arg1 = (wxFSFile *) 0 ;
8153 wxString *result;
8154 PyObject * obj0 = 0 ;
8155 char *kwnames[] = {
8156 (char *) "self", NULL
8157 };
8158
8159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8161 if (SWIG_arg_fail(1)) SWIG_fail;
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 {
8165 wxString const &_result_ref = (arg1)->GetLocation();
8166 result = (wxString *) &_result_ref;
8167 }
8168
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 {
8173 #if wxUSE_UNICODE
8174 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8175 #else
8176 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8177 #endif
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj;
8187 wxFSFile *arg1 = (wxFSFile *) 0 ;
8188 wxString *result;
8189 PyObject * obj0 = 0 ;
8190 char *kwnames[] = {
8191 (char *) "self", NULL
8192 };
8193
8194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8196 if (SWIG_arg_fail(1)) SWIG_fail;
8197 {
8198 PyThreadState* __tstate = wxPyBeginAllowThreads();
8199 {
8200 wxString const &_result_ref = (arg1)->GetAnchor();
8201 result = (wxString *) &_result_ref;
8202 }
8203
8204 wxPyEndAllowThreads(__tstate);
8205 if (PyErr_Occurred()) SWIG_fail;
8206 }
8207 {
8208 #if wxUSE_UNICODE
8209 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8210 #else
8211 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8212 #endif
8213 }
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj;
8222 wxFSFile *arg1 = (wxFSFile *) 0 ;
8223 wxDateTime result;
8224 PyObject * obj0 = 0 ;
8225 char *kwnames[] = {
8226 (char *) "self", NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8231 if (SWIG_arg_fail(1)) SWIG_fail;
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (arg1)->GetModificationTime();
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 {
8240 wxDateTime * resultptr;
8241 resultptr = new wxDateTime((wxDateTime &)(result));
8242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8243 }
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8251 PyObject *obj;
8252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8253 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8254 Py_INCREF(obj);
8255 return Py_BuildValue((char *)"");
8256 }
8257 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8258 PyObject *obj;
8259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8260 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8261 Py_INCREF(obj);
8262 return Py_BuildValue((char *)"");
8263 }
8264 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyFileSystemHandler *result;
8267 char *kwnames[] = {
8268 NULL
8269 };
8270
8271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8275
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8280 return resultobj;
8281 fail:
8282 return NULL;
8283 }
8284
8285
8286 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj;
8288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8289 PyObject *arg2 = (PyObject *) 0 ;
8290 PyObject *arg3 = (PyObject *) 0 ;
8291 PyObject * obj0 = 0 ;
8292 PyObject * obj1 = 0 ;
8293 PyObject * obj2 = 0 ;
8294 char *kwnames[] = {
8295 (char *) "self",(char *) "self",(char *) "_class", NULL
8296 };
8297
8298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8300 if (SWIG_arg_fail(1)) SWIG_fail;
8301 arg2 = obj1;
8302 arg3 = obj2;
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 (arg1)->_setCallbackInfo(arg2,arg3);
8306
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 Py_INCREF(Py_None); resultobj = Py_None;
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj;
8319 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8320 wxString *arg2 = 0 ;
8321 bool result;
8322 bool temp2 = false ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 char *kwnames[] = {
8326 (char *) "self",(char *) "location", NULL
8327 };
8328
8329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8331 if (SWIG_arg_fail(1)) SWIG_fail;
8332 {
8333 arg2 = wxString_in_helper(obj1);
8334 if (arg2 == NULL) SWIG_fail;
8335 temp2 = true;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8346 }
8347 {
8348 if (temp2)
8349 delete arg2;
8350 }
8351 return resultobj;
8352 fail:
8353 {
8354 if (temp2)
8355 delete arg2;
8356 }
8357 return NULL;
8358 }
8359
8360
8361 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj;
8363 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8364 wxFileSystem *arg2 = 0 ;
8365 wxString *arg3 = 0 ;
8366 wxFSFile *result;
8367 bool temp3 = false ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 PyObject * obj2 = 0 ;
8371 char *kwnames[] = {
8372 (char *) "self",(char *) "fs",(char *) "location", NULL
8373 };
8374
8375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8377 if (SWIG_arg_fail(1)) SWIG_fail;
8378 {
8379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8380 if (SWIG_arg_fail(2)) SWIG_fail;
8381 if (arg2 == NULL) {
8382 SWIG_null_ref("wxFileSystem");
8383 }
8384 if (SWIG_arg_fail(2)) SWIG_fail;
8385 }
8386 {
8387 arg3 = wxString_in_helper(obj2);
8388 if (arg3 == NULL) SWIG_fail;
8389 temp3 = true;
8390 }
8391 {
8392 PyThreadState* __tstate = wxPyBeginAllowThreads();
8393 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8394
8395 wxPyEndAllowThreads(__tstate);
8396 if (PyErr_Occurred()) SWIG_fail;
8397 }
8398 {
8399 resultobj = wxPyMake_wxObject(result, 1);
8400 }
8401 {
8402 if (temp3)
8403 delete arg3;
8404 }
8405 return resultobj;
8406 fail:
8407 {
8408 if (temp3)
8409 delete arg3;
8410 }
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj;
8417 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8418 wxString *arg2 = 0 ;
8419 int arg3 = (int) 0 ;
8420 wxString result;
8421 bool temp2 = false ;
8422 PyObject * obj0 = 0 ;
8423 PyObject * obj1 = 0 ;
8424 PyObject * obj2 = 0 ;
8425 char *kwnames[] = {
8426 (char *) "self",(char *) "spec",(char *) "flags", NULL
8427 };
8428
8429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8431 if (SWIG_arg_fail(1)) SWIG_fail;
8432 {
8433 arg2 = wxString_in_helper(obj1);
8434 if (arg2 == NULL) SWIG_fail;
8435 temp2 = true;
8436 }
8437 if (obj2) {
8438 {
8439 arg3 = (int)(SWIG_As_int(obj2));
8440 if (SWIG_arg_fail(3)) SWIG_fail;
8441 }
8442 }
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8446
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 {
8451 #if wxUSE_UNICODE
8452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8453 #else
8454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8455 #endif
8456 }
8457 {
8458 if (temp2)
8459 delete arg2;
8460 }
8461 return resultobj;
8462 fail:
8463 {
8464 if (temp2)
8465 delete arg2;
8466 }
8467 return NULL;
8468 }
8469
8470
8471 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8472 PyObject *resultobj;
8473 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8474 wxString result;
8475 PyObject * obj0 = 0 ;
8476 char *kwnames[] = {
8477 (char *) "self", NULL
8478 };
8479
8480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8482 if (SWIG_arg_fail(1)) SWIG_fail;
8483 {
8484 PyThreadState* __tstate = wxPyBeginAllowThreads();
8485 result = (arg1)->FindNext();
8486
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 {
8491 #if wxUSE_UNICODE
8492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8493 #else
8494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8495 #endif
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8504 PyObject *resultobj;
8505 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8506 wxString *arg2 = 0 ;
8507 wxString result;
8508 bool temp2 = false ;
8509 PyObject * obj0 = 0 ;
8510 PyObject * obj1 = 0 ;
8511 char *kwnames[] = {
8512 (char *) "self",(char *) "location", NULL
8513 };
8514
8515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8517 if (SWIG_arg_fail(1)) SWIG_fail;
8518 {
8519 arg2 = wxString_in_helper(obj1);
8520 if (arg2 == NULL) SWIG_fail;
8521 temp2 = true;
8522 }
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 result = (arg1)->GetProtocol((wxString const &)*arg2);
8526
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 {
8531 #if wxUSE_UNICODE
8532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8533 #else
8534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8535 #endif
8536 }
8537 {
8538 if (temp2)
8539 delete arg2;
8540 }
8541 return resultobj;
8542 fail:
8543 {
8544 if (temp2)
8545 delete arg2;
8546 }
8547 return NULL;
8548 }
8549
8550
8551 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj;
8553 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8554 wxString *arg2 = 0 ;
8555 wxString result;
8556 bool temp2 = false ;
8557 PyObject * obj0 = 0 ;
8558 PyObject * obj1 = 0 ;
8559 char *kwnames[] = {
8560 (char *) "self",(char *) "location", NULL
8561 };
8562
8563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8565 if (SWIG_arg_fail(1)) SWIG_fail;
8566 {
8567 arg2 = wxString_in_helper(obj1);
8568 if (arg2 == NULL) SWIG_fail;
8569 temp2 = true;
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8574
8575 wxPyEndAllowThreads(__tstate);
8576 if (PyErr_Occurred()) SWIG_fail;
8577 }
8578 {
8579 #if wxUSE_UNICODE
8580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8581 #else
8582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8583 #endif
8584 }
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return resultobj;
8590 fail:
8591 {
8592 if (temp2)
8593 delete arg2;
8594 }
8595 return NULL;
8596 }
8597
8598
8599 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj;
8601 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8602 wxString *arg2 = 0 ;
8603 wxString result;
8604 bool temp2 = false ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 char *kwnames[] = {
8608 (char *) "self",(char *) "location", NULL
8609 };
8610
8611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 {
8615 arg2 = wxString_in_helper(obj1);
8616 if (arg2 == NULL) SWIG_fail;
8617 temp2 = true;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 result = (arg1)->GetAnchor((wxString const &)*arg2);
8622
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 {
8627 #if wxUSE_UNICODE
8628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8629 #else
8630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8631 #endif
8632 }
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 return resultobj;
8638 fail:
8639 {
8640 if (temp2)
8641 delete arg2;
8642 }
8643 return NULL;
8644 }
8645
8646
8647 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj;
8649 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8650 wxString *arg2 = 0 ;
8651 wxString result;
8652 bool temp2 = false ;
8653 PyObject * obj0 = 0 ;
8654 PyObject * obj1 = 0 ;
8655 char *kwnames[] = {
8656 (char *) "self",(char *) "location", NULL
8657 };
8658
8659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8661 if (SWIG_arg_fail(1)) SWIG_fail;
8662 {
8663 arg2 = wxString_in_helper(obj1);
8664 if (arg2 == NULL) SWIG_fail;
8665 temp2 = true;
8666 }
8667 {
8668 PyThreadState* __tstate = wxPyBeginAllowThreads();
8669 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8670
8671 wxPyEndAllowThreads(__tstate);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 {
8675 #if wxUSE_UNICODE
8676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8677 #else
8678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8679 #endif
8680 }
8681 {
8682 if (temp2)
8683 delete arg2;
8684 }
8685 return resultobj;
8686 fail:
8687 {
8688 if (temp2)
8689 delete arg2;
8690 }
8691 return NULL;
8692 }
8693
8694
8695 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8696 PyObject *resultobj;
8697 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8698 wxString *arg2 = 0 ;
8699 wxString result;
8700 bool temp2 = false ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char *kwnames[] = {
8704 (char *) "self",(char *) "location", NULL
8705 };
8706
8707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8709 if (SWIG_arg_fail(1)) SWIG_fail;
8710 {
8711 arg2 = wxString_in_helper(obj1);
8712 if (arg2 == NULL) SWIG_fail;
8713 temp2 = true;
8714 }
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8718
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 {
8723 #if wxUSE_UNICODE
8724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8725 #else
8726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8727 #endif
8728 }
8729 {
8730 if (temp2)
8731 delete arg2;
8732 }
8733 return resultobj;
8734 fail:
8735 {
8736 if (temp2)
8737 delete arg2;
8738 }
8739 return NULL;
8740 }
8741
8742
8743 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8744 PyObject *obj;
8745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8746 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8747 Py_INCREF(obj);
8748 return Py_BuildValue((char *)"");
8749 }
8750 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj;
8752 wxFileSystem *result;
8753 char *kwnames[] = {
8754 NULL
8755 };
8756
8757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 result = (wxFileSystem *)new wxFileSystem();
8761
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 {
8766 resultobj = wxPyMake_wxObject(result, 1);
8767 }
8768 return resultobj;
8769 fail:
8770 return NULL;
8771 }
8772
8773
8774 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8775 PyObject *resultobj;
8776 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8777 PyObject * obj0 = 0 ;
8778 char *kwnames[] = {
8779 (char *) "self", NULL
8780 };
8781
8782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8784 if (SWIG_arg_fail(1)) SWIG_fail;
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 delete arg1;
8788
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 Py_INCREF(Py_None); resultobj = Py_None;
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8800 PyObject *resultobj;
8801 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8802 wxString *arg2 = 0 ;
8803 bool arg3 = (bool) false ;
8804 bool temp2 = false ;
8805 PyObject * obj0 = 0 ;
8806 PyObject * obj1 = 0 ;
8807 PyObject * obj2 = 0 ;
8808 char *kwnames[] = {
8809 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8810 };
8811
8812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8814 if (SWIG_arg_fail(1)) SWIG_fail;
8815 {
8816 arg2 = wxString_in_helper(obj1);
8817 if (arg2 == NULL) SWIG_fail;
8818 temp2 = true;
8819 }
8820 if (obj2) {
8821 {
8822 arg3 = (bool)(SWIG_As_bool(obj2));
8823 if (SWIG_arg_fail(3)) SWIG_fail;
8824 }
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8829
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 Py_INCREF(Py_None); resultobj = Py_None;
8834 {
8835 if (temp2)
8836 delete arg2;
8837 }
8838 return resultobj;
8839 fail:
8840 {
8841 if (temp2)
8842 delete arg2;
8843 }
8844 return NULL;
8845 }
8846
8847
8848 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj;
8850 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8851 wxString result;
8852 PyObject * obj0 = 0 ;
8853 char *kwnames[] = {
8854 (char *) "self", NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8859 if (SWIG_arg_fail(1)) SWIG_fail;
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = (arg1)->GetPath();
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 #if wxUSE_UNICODE
8869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8870 #else
8871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8872 #endif
8873 }
8874 return resultobj;
8875 fail:
8876 return NULL;
8877 }
8878
8879
8880 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj;
8882 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8883 wxString *arg2 = 0 ;
8884 wxFSFile *result;
8885 bool temp2 = false ;
8886 PyObject * obj0 = 0 ;
8887 PyObject * obj1 = 0 ;
8888 char *kwnames[] = {
8889 (char *) "self",(char *) "location", NULL
8890 };
8891
8892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8894 if (SWIG_arg_fail(1)) SWIG_fail;
8895 {
8896 arg2 = wxString_in_helper(obj1);
8897 if (arg2 == NULL) SWIG_fail;
8898 temp2 = true;
8899 }
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 resultobj = wxPyMake_wxObject(result, 1);
8909 }
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return resultobj;
8915 fail:
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8927 wxString *arg2 = 0 ;
8928 int arg3 = (int) 0 ;
8929 wxString result;
8930 bool temp2 = false ;
8931 PyObject * obj0 = 0 ;
8932 PyObject * obj1 = 0 ;
8933 PyObject * obj2 = 0 ;
8934 char *kwnames[] = {
8935 (char *) "self",(char *) "spec",(char *) "flags", NULL
8936 };
8937
8938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8940 if (SWIG_arg_fail(1)) SWIG_fail;
8941 {
8942 arg2 = wxString_in_helper(obj1);
8943 if (arg2 == NULL) SWIG_fail;
8944 temp2 = true;
8945 }
8946 if (obj2) {
8947 {
8948 arg3 = (int)(SWIG_As_int(obj2));
8949 if (SWIG_arg_fail(3)) SWIG_fail;
8950 }
8951 }
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 #if wxUSE_UNICODE
8961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8962 #else
8963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8964 #endif
8965 }
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return resultobj;
8971 fail:
8972 {
8973 if (temp2)
8974 delete arg2;
8975 }
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8983 wxString result;
8984 PyObject * obj0 = 0 ;
8985 char *kwnames[] = {
8986 (char *) "self", NULL
8987 };
8988
8989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8991 if (SWIG_arg_fail(1)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (arg1)->FindNext();
8995
8996 wxPyEndAllowThreads(__tstate);
8997 if (PyErr_Occurred()) SWIG_fail;
8998 }
8999 {
9000 #if wxUSE_UNICODE
9001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9002 #else
9003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9004 #endif
9005 }
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9013 PyObject *resultobj;
9014 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9015 PyObject * obj0 = 0 ;
9016 char *kwnames[] = {
9017 (char *) "handler", NULL
9018 };
9019
9020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9022 if (SWIG_arg_fail(1)) SWIG_fail;
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 wxFileSystem::AddHandler(arg1);
9026
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 Py_INCREF(Py_None); resultobj = Py_None;
9031 return resultobj;
9032 fail:
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj;
9039 char *kwnames[] = {
9040 NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 wxFileSystem::CleanUpHandlers();
9047
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 Py_INCREF(Py_None); resultobj = Py_None;
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj;
9060 wxString *arg1 = 0 ;
9061 wxString result;
9062 bool temp1 = false ;
9063 PyObject * obj0 = 0 ;
9064 char *kwnames[] = {
9065 (char *) "filename", NULL
9066 };
9067
9068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9069 {
9070 arg1 = wxString_in_helper(obj0);
9071 if (arg1 == NULL) SWIG_fail;
9072 temp1 = true;
9073 }
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 {
9082 #if wxUSE_UNICODE
9083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9084 #else
9085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9086 #endif
9087 }
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return resultobj;
9093 fail:
9094 {
9095 if (temp1)
9096 delete arg1;
9097 }
9098 return NULL;
9099 }
9100
9101
9102 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9103 PyObject *resultobj;
9104 wxString *arg1 = 0 ;
9105 wxString result;
9106 bool temp1 = false ;
9107 PyObject * obj0 = 0 ;
9108 char *kwnames[] = {
9109 (char *) "url", NULL
9110 };
9111
9112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9113 {
9114 arg1 = wxString_in_helper(obj0);
9115 if (arg1 == NULL) SWIG_fail;
9116 temp1 = true;
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = FileSystem_URLToFileName((wxString const &)*arg1);
9121
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 {
9126 #if wxUSE_UNICODE
9127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9128 #else
9129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9130 #endif
9131 }
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return resultobj;
9137 fail:
9138 {
9139 if (temp1)
9140 delete arg1;
9141 }
9142 return NULL;
9143 }
9144
9145
9146 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9147 PyObject *obj;
9148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9149 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9150 Py_INCREF(obj);
9151 return Py_BuildValue((char *)"");
9152 }
9153 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxInternetFSHandler *result;
9156 char *kwnames[] = {
9157 NULL
9158 };
9159
9160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9164
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9169 return resultobj;
9170 fail:
9171 return NULL;
9172 }
9173
9174
9175 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9176 PyObject *resultobj;
9177 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9178 wxString *arg2 = 0 ;
9179 bool result;
9180 bool temp2 = false ;
9181 PyObject * obj0 = 0 ;
9182 PyObject * obj1 = 0 ;
9183 char *kwnames[] = {
9184 (char *) "self",(char *) "location", NULL
9185 };
9186
9187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9189 if (SWIG_arg_fail(1)) SWIG_fail;
9190 {
9191 arg2 = wxString_in_helper(obj1);
9192 if (arg2 == NULL) SWIG_fail;
9193 temp2 = true;
9194 }
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9198
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 {
9203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9204 }
9205 {
9206 if (temp2)
9207 delete arg2;
9208 }
9209 return resultobj;
9210 fail:
9211 {
9212 if (temp2)
9213 delete arg2;
9214 }
9215 return NULL;
9216 }
9217
9218
9219 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9220 PyObject *resultobj;
9221 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9222 wxFileSystem *arg2 = 0 ;
9223 wxString *arg3 = 0 ;
9224 wxFSFile *result;
9225 bool temp3 = false ;
9226 PyObject * obj0 = 0 ;
9227 PyObject * obj1 = 0 ;
9228 PyObject * obj2 = 0 ;
9229 char *kwnames[] = {
9230 (char *) "self",(char *) "fs",(char *) "location", NULL
9231 };
9232
9233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9235 if (SWIG_arg_fail(1)) SWIG_fail;
9236 {
9237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9238 if (SWIG_arg_fail(2)) SWIG_fail;
9239 if (arg2 == NULL) {
9240 SWIG_null_ref("wxFileSystem");
9241 }
9242 if (SWIG_arg_fail(2)) SWIG_fail;
9243 }
9244 {
9245 arg3 = wxString_in_helper(obj2);
9246 if (arg3 == NULL) SWIG_fail;
9247 temp3 = true;
9248 }
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9252
9253 wxPyEndAllowThreads(__tstate);
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 {
9257 resultobj = wxPyMake_wxObject(result, 1);
9258 }
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return resultobj;
9264 fail:
9265 {
9266 if (temp3)
9267 delete arg3;
9268 }
9269 return NULL;
9270 }
9271
9272
9273 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9274 PyObject *obj;
9275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9276 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9277 Py_INCREF(obj);
9278 return Py_BuildValue((char *)"");
9279 }
9280 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxZipFSHandler *result;
9283 char *kwnames[] = {
9284 NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (wxZipFSHandler *)new wxZipFSHandler();
9291
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9303 PyObject *resultobj;
9304 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9305 wxString *arg2 = 0 ;
9306 bool result;
9307 bool temp2 = false ;
9308 PyObject * obj0 = 0 ;
9309 PyObject * obj1 = 0 ;
9310 char *kwnames[] = {
9311 (char *) "self",(char *) "location", NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9316 if (SWIG_arg_fail(1)) SWIG_fail;
9317 {
9318 arg2 = wxString_in_helper(obj1);
9319 if (arg2 == NULL) SWIG_fail;
9320 temp2 = true;
9321 }
9322 {
9323 PyThreadState* __tstate = wxPyBeginAllowThreads();
9324 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9325
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 {
9330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9331 }
9332 {
9333 if (temp2)
9334 delete arg2;
9335 }
9336 return resultobj;
9337 fail:
9338 {
9339 if (temp2)
9340 delete arg2;
9341 }
9342 return NULL;
9343 }
9344
9345
9346 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9347 PyObject *resultobj;
9348 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9349 wxFileSystem *arg2 = 0 ;
9350 wxString *arg3 = 0 ;
9351 wxFSFile *result;
9352 bool temp3 = false ;
9353 PyObject * obj0 = 0 ;
9354 PyObject * obj1 = 0 ;
9355 PyObject * obj2 = 0 ;
9356 char *kwnames[] = {
9357 (char *) "self",(char *) "fs",(char *) "location", NULL
9358 };
9359
9360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9362 if (SWIG_arg_fail(1)) SWIG_fail;
9363 {
9364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9365 if (SWIG_arg_fail(2)) SWIG_fail;
9366 if (arg2 == NULL) {
9367 SWIG_null_ref("wxFileSystem");
9368 }
9369 if (SWIG_arg_fail(2)) SWIG_fail;
9370 }
9371 {
9372 arg3 = wxString_in_helper(obj2);
9373 if (arg3 == NULL) SWIG_fail;
9374 temp3 = true;
9375 }
9376 {
9377 PyThreadState* __tstate = wxPyBeginAllowThreads();
9378 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9379
9380 wxPyEndAllowThreads(__tstate);
9381 if (PyErr_Occurred()) SWIG_fail;
9382 }
9383 {
9384 resultobj = wxPyMake_wxObject(result, 1);
9385 }
9386 {
9387 if (temp3)
9388 delete arg3;
9389 }
9390 return resultobj;
9391 fail:
9392 {
9393 if (temp3)
9394 delete arg3;
9395 }
9396 return NULL;
9397 }
9398
9399
9400 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9401 PyObject *resultobj;
9402 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9403 wxString *arg2 = 0 ;
9404 int arg3 = (int) 0 ;
9405 wxString result;
9406 bool temp2 = false ;
9407 PyObject * obj0 = 0 ;
9408 PyObject * obj1 = 0 ;
9409 PyObject * obj2 = 0 ;
9410 char *kwnames[] = {
9411 (char *) "self",(char *) "spec",(char *) "flags", NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9416 if (SWIG_arg_fail(1)) SWIG_fail;
9417 {
9418 arg2 = wxString_in_helper(obj1);
9419 if (arg2 == NULL) SWIG_fail;
9420 temp2 = true;
9421 }
9422 if (obj2) {
9423 {
9424 arg3 = (int)(SWIG_As_int(obj2));
9425 if (SWIG_arg_fail(3)) SWIG_fail;
9426 }
9427 }
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9431
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 {
9436 #if wxUSE_UNICODE
9437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9438 #else
9439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9440 #endif
9441 }
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return resultobj;
9447 fail:
9448 {
9449 if (temp2)
9450 delete arg2;
9451 }
9452 return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9459 wxString result;
9460 PyObject * obj0 = 0 ;
9461 char *kwnames[] = {
9462 (char *) "self", NULL
9463 };
9464
9465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9467 if (SWIG_arg_fail(1)) SWIG_fail;
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 result = (arg1)->FindNext();
9471
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 {
9476 #if wxUSE_UNICODE
9477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9478 #else
9479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9480 #endif
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9489 PyObject *obj;
9490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9491 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9492 Py_INCREF(obj);
9493 return Py_BuildValue((char *)"");
9494 }
9495 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxString *arg1 = 0 ;
9498 wxImage *arg2 = 0 ;
9499 long arg3 ;
9500 bool temp1 = false ;
9501 PyObject * obj0 = 0 ;
9502 PyObject * obj1 = 0 ;
9503 PyObject * obj2 = 0 ;
9504 char *kwnames[] = {
9505 (char *) "filename",(char *) "image",(char *) "type", NULL
9506 };
9507
9508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9509 {
9510 arg1 = wxString_in_helper(obj0);
9511 if (arg1 == NULL) SWIG_fail;
9512 temp1 = true;
9513 }
9514 {
9515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9516 if (SWIG_arg_fail(2)) SWIG_fail;
9517 if (arg2 == NULL) {
9518 SWIG_null_ref("wxImage");
9519 }
9520 if (SWIG_arg_fail(2)) SWIG_fail;
9521 }
9522 {
9523 arg3 = (long)(SWIG_As_long(obj2));
9524 if (SWIG_arg_fail(3)) SWIG_fail;
9525 }
9526 {
9527 PyThreadState* __tstate = wxPyBeginAllowThreads();
9528 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9529
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 Py_INCREF(Py_None); resultobj = Py_None;
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return resultobj;
9539 fail:
9540 {
9541 if (temp1)
9542 delete arg1;
9543 }
9544 return NULL;
9545 }
9546
9547
9548 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9549 PyObject *resultobj;
9550 wxString *arg1 = 0 ;
9551 wxBitmap *arg2 = 0 ;
9552 long arg3 ;
9553 bool temp1 = false ;
9554 PyObject * obj0 = 0 ;
9555 PyObject * obj1 = 0 ;
9556 PyObject * obj2 = 0 ;
9557 char *kwnames[] = {
9558 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9559 };
9560
9561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9562 {
9563 arg1 = wxString_in_helper(obj0);
9564 if (arg1 == NULL) SWIG_fail;
9565 temp1 = true;
9566 }
9567 {
9568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9569 if (SWIG_arg_fail(2)) SWIG_fail;
9570 if (arg2 == NULL) {
9571 SWIG_null_ref("wxBitmap");
9572 }
9573 if (SWIG_arg_fail(2)) SWIG_fail;
9574 }
9575 {
9576 arg3 = (long)(SWIG_As_long(obj2));
9577 if (SWIG_arg_fail(3)) SWIG_fail;
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 Py_INCREF(Py_None); resultobj = Py_None;
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return resultobj;
9592 fail:
9593 {
9594 if (temp1)
9595 delete arg1;
9596 }
9597 return NULL;
9598 }
9599
9600
9601 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9602 PyObject *resultobj;
9603 wxString *arg1 = 0 ;
9604 PyObject *arg2 = (PyObject *) 0 ;
9605 bool temp1 = false ;
9606 PyObject * obj0 = 0 ;
9607 PyObject * obj1 = 0 ;
9608 char *kwnames[] = {
9609 (char *) "filename",(char *) "data", NULL
9610 };
9611
9612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9613 {
9614 arg1 = wxString_in_helper(obj0);
9615 if (arg1 == NULL) SWIG_fail;
9616 temp1 = true;
9617 }
9618 arg2 = obj1;
9619 {
9620 PyThreadState* __tstate = wxPyBeginAllowThreads();
9621 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9622
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 Py_INCREF(Py_None); resultobj = Py_None;
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return resultobj;
9632 fail:
9633 {
9634 if (temp1)
9635 delete arg1;
9636 }
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxMemoryFSHandler *result;
9644 char *kwnames[] = {
9645 NULL
9646 };
9647
9648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj;
9665 wxString *arg1 = 0 ;
9666 bool temp1 = false ;
9667 PyObject * obj0 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "filename", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9673 {
9674 arg1 = wxString_in_helper(obj0);
9675 if (arg1 == NULL) SWIG_fail;
9676 temp1 = true;
9677 }
9678 {
9679 PyThreadState* __tstate = wxPyBeginAllowThreads();
9680 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9681
9682 wxPyEndAllowThreads(__tstate);
9683 if (PyErr_Occurred()) SWIG_fail;
9684 }
9685 Py_INCREF(Py_None); resultobj = Py_None;
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return resultobj;
9691 fail:
9692 {
9693 if (temp1)
9694 delete arg1;
9695 }
9696 return NULL;
9697 }
9698
9699
9700 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj;
9702 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9703 wxString *arg2 = 0 ;
9704 bool result;
9705 bool temp2 = false ;
9706 PyObject * obj0 = 0 ;
9707 PyObject * obj1 = 0 ;
9708 char *kwnames[] = {
9709 (char *) "self",(char *) "location", NULL
9710 };
9711
9712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9714 if (SWIG_arg_fail(1)) SWIG_fail;
9715 {
9716 arg2 = wxString_in_helper(obj1);
9717 if (arg2 == NULL) SWIG_fail;
9718 temp2 = true;
9719 }
9720 {
9721 PyThreadState* __tstate = wxPyBeginAllowThreads();
9722 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9723
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 {
9728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9729 }
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return resultobj;
9735 fail:
9736 {
9737 if (temp2)
9738 delete arg2;
9739 }
9740 return NULL;
9741 }
9742
9743
9744 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj;
9746 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9747 wxFileSystem *arg2 = 0 ;
9748 wxString *arg3 = 0 ;
9749 wxFSFile *result;
9750 bool temp3 = false ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 PyObject * obj2 = 0 ;
9754 char *kwnames[] = {
9755 (char *) "self",(char *) "fs",(char *) "location", NULL
9756 };
9757
9758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9760 if (SWIG_arg_fail(1)) SWIG_fail;
9761 {
9762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9763 if (SWIG_arg_fail(2)) SWIG_fail;
9764 if (arg2 == NULL) {
9765 SWIG_null_ref("wxFileSystem");
9766 }
9767 if (SWIG_arg_fail(2)) SWIG_fail;
9768 }
9769 {
9770 arg3 = wxString_in_helper(obj2);
9771 if (arg3 == NULL) SWIG_fail;
9772 temp3 = true;
9773 }
9774 {
9775 PyThreadState* __tstate = wxPyBeginAllowThreads();
9776 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9777
9778 wxPyEndAllowThreads(__tstate);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 {
9782 resultobj = wxPyMake_wxObject(result, 1);
9783 }
9784 {
9785 if (temp3)
9786 delete arg3;
9787 }
9788 return resultobj;
9789 fail:
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9801 wxString *arg2 = 0 ;
9802 int arg3 = (int) 0 ;
9803 wxString result;
9804 bool temp2 = false ;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 PyObject * obj2 = 0 ;
9808 char *kwnames[] = {
9809 (char *) "self",(char *) "spec",(char *) "flags", NULL
9810 };
9811
9812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9814 if (SWIG_arg_fail(1)) SWIG_fail;
9815 {
9816 arg2 = wxString_in_helper(obj1);
9817 if (arg2 == NULL) SWIG_fail;
9818 temp2 = true;
9819 }
9820 if (obj2) {
9821 {
9822 arg3 = (int)(SWIG_As_int(obj2));
9823 if (SWIG_arg_fail(3)) SWIG_fail;
9824 }
9825 }
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 {
9834 #if wxUSE_UNICODE
9835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9836 #else
9837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9838 #endif
9839 }
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return resultobj;
9845 fail:
9846 {
9847 if (temp2)
9848 delete arg2;
9849 }
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9857 wxString result;
9858 PyObject * obj0 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 result = (arg1)->FindNext();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 #if wxUSE_UNICODE
9875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9876 #else
9877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9878 #endif
9879 }
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9887 PyObject *obj;
9888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9889 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9890 Py_INCREF(obj);
9891 return Py_BuildValue((char *)"");
9892 }
9893 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9896 wxString result;
9897 PyObject * obj0 = 0 ;
9898 char *kwnames[] = {
9899 (char *) "self", NULL
9900 };
9901
9902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9904 if (SWIG_arg_fail(1)) SWIG_fail;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 result = (arg1)->GetName();
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 {
9913 #if wxUSE_UNICODE
9914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9915 #else
9916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9917 #endif
9918 }
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9928 wxString result;
9929 PyObject * obj0 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "self", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9936 if (SWIG_arg_fail(1)) SWIG_fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (arg1)->GetExtension();
9940
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 {
9945 #if wxUSE_UNICODE
9946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9947 #else
9948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9949 #endif
9950 }
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9958 PyObject *resultobj;
9959 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9960 long result;
9961 PyObject * obj0 = 0 ;
9962 char *kwnames[] = {
9963 (char *) "self", NULL
9964 };
9965
9966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9968 if (SWIG_arg_fail(1)) SWIG_fail;
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (long)(arg1)->GetType();
9972
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 {
9977 resultobj = SWIG_From_long((long)(result));
9978 }
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj;
9987 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9988 wxString result;
9989 PyObject * obj0 = 0 ;
9990 char *kwnames[] = {
9991 (char *) "self", NULL
9992 };
9993
9994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9996 if (SWIG_arg_fail(1)) SWIG_fail;
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (arg1)->GetMimeType();
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 #if wxUSE_UNICODE
10006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10007 #else
10008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10009 #endif
10010 }
10011 return resultobj;
10012 fail:
10013 return NULL;
10014 }
10015
10016
10017 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10018 PyObject *resultobj;
10019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10020 wxString *arg2 = 0 ;
10021 bool result;
10022 bool temp2 = false ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 char *kwnames[] = {
10026 (char *) "self",(char *) "name", NULL
10027 };
10028
10029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10031 if (SWIG_arg_fail(1)) SWIG_fail;
10032 {
10033 arg2 = wxString_in_helper(obj1);
10034 if (arg2 == NULL) SWIG_fail;
10035 temp2 = true;
10036 }
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10040
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 {
10045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10046 }
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return resultobj;
10052 fail:
10053 {
10054 if (temp2)
10055 delete arg2;
10056 }
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10064 wxString *arg2 = 0 ;
10065 bool temp2 = false ;
10066 PyObject * obj0 = 0 ;
10067 PyObject * obj1 = 0 ;
10068 char *kwnames[] = {
10069 (char *) "self",(char *) "name", NULL
10070 };
10071
10072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10074 if (SWIG_arg_fail(1)) SWIG_fail;
10075 {
10076 arg2 = wxString_in_helper(obj1);
10077 if (arg2 == NULL) SWIG_fail;
10078 temp2 = true;
10079 }
10080 {
10081 PyThreadState* __tstate = wxPyBeginAllowThreads();
10082 (arg1)->SetName((wxString const &)*arg2);
10083
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 Py_INCREF(Py_None); resultobj = Py_None;
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 return resultobj;
10093 fail:
10094 {
10095 if (temp2)
10096 delete arg2;
10097 }
10098 return NULL;
10099 }
10100
10101
10102 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj;
10104 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10105 wxString *arg2 = 0 ;
10106 bool temp2 = false ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char *kwnames[] = {
10110 (char *) "self",(char *) "extension", NULL
10111 };
10112
10113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10115 if (SWIG_arg_fail(1)) SWIG_fail;
10116 {
10117 arg2 = wxString_in_helper(obj1);
10118 if (arg2 == NULL) SWIG_fail;
10119 temp2 = true;
10120 }
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 (arg1)->SetExtension((wxString const &)*arg2);
10124
10125 wxPyEndAllowThreads(__tstate);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 Py_INCREF(Py_None); resultobj = Py_None;
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return resultobj;
10134 fail:
10135 {
10136 if (temp2)
10137 delete arg2;
10138 }
10139 return NULL;
10140 }
10141
10142
10143 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10144 PyObject *resultobj;
10145 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10146 long arg2 ;
10147 PyObject * obj0 = 0 ;
10148 PyObject * obj1 = 0 ;
10149 char *kwnames[] = {
10150 (char *) "self",(char *) "type", NULL
10151 };
10152
10153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10155 if (SWIG_arg_fail(1)) SWIG_fail;
10156 {
10157 arg2 = (long)(SWIG_As_long(obj1));
10158 if (SWIG_arg_fail(2)) SWIG_fail;
10159 }
10160 {
10161 PyThreadState* __tstate = wxPyBeginAllowThreads();
10162 (arg1)->SetType(arg2);
10163
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 Py_INCREF(Py_None); resultobj = Py_None;
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj;
10176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10177 wxString *arg2 = 0 ;
10178 bool temp2 = false ;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 char *kwnames[] = {
10182 (char *) "self",(char *) "mimetype", NULL
10183 };
10184
10185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10187 if (SWIG_arg_fail(1)) SWIG_fail;
10188 {
10189 arg2 = wxString_in_helper(obj1);
10190 if (arg2 == NULL) SWIG_fail;
10191 temp2 = true;
10192 }
10193 {
10194 PyThreadState* __tstate = wxPyBeginAllowThreads();
10195 (arg1)->SetMimeType((wxString const &)*arg2);
10196
10197 wxPyEndAllowThreads(__tstate);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 Py_INCREF(Py_None); resultobj = Py_None;
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return resultobj;
10206 fail:
10207 {
10208 if (temp2)
10209 delete arg2;
10210 }
10211 return NULL;
10212 }
10213
10214
10215 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10216 PyObject *obj;
10217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10218 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10219 Py_INCREF(obj);
10220 return Py_BuildValue((char *)"");
10221 }
10222 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj;
10224 wxImageHistogram *result;
10225 char *kwnames[] = {
10226 NULL
10227 };
10228
10229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (wxImageHistogram *)new wxImageHistogram();
10233
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10238 return resultobj;
10239 fail:
10240 return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj;
10246 unsigned char arg1 ;
10247 unsigned char arg2 ;
10248 unsigned char arg3 ;
10249 unsigned long result;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 PyObject * obj2 = 0 ;
10253 char *kwnames[] = {
10254 (char *) "r",(char *) "g",(char *) "b", NULL
10255 };
10256
10257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10258 {
10259 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10260 if (SWIG_arg_fail(1)) SWIG_fail;
10261 }
10262 {
10263 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10264 if (SWIG_arg_fail(2)) SWIG_fail;
10265 }
10266 {
10267 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10268 if (SWIG_arg_fail(3)) SWIG_fail;
10269 }
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10273
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10279 }
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj;
10288 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10289 unsigned char *arg2 = (unsigned char *) 0 ;
10290 unsigned char *arg3 = (unsigned char *) 0 ;
10291 unsigned char *arg4 = (unsigned char *) 0 ;
10292 unsigned char arg5 = (unsigned char) 1 ;
10293 unsigned char arg6 = (unsigned char) 0 ;
10294 unsigned char arg7 = (unsigned char) 0 ;
10295 bool result;
10296 unsigned char temp2 ;
10297 int res2 = 0 ;
10298 unsigned char temp3 ;
10299 int res3 = 0 ;
10300 unsigned char temp4 ;
10301 int res4 = 0 ;
10302 PyObject * obj0 = 0 ;
10303 PyObject * obj1 = 0 ;
10304 PyObject * obj2 = 0 ;
10305 PyObject * obj3 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10308 };
10309
10310 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10311 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10312 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10315 if (SWIG_arg_fail(1)) SWIG_fail;
10316 if (obj1) {
10317 {
10318 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10319 if (SWIG_arg_fail(5)) SWIG_fail;
10320 }
10321 }
10322 if (obj2) {
10323 {
10324 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10325 if (SWIG_arg_fail(6)) SWIG_fail;
10326 }
10327 }
10328 if (obj3) {
10329 {
10330 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10331 if (SWIG_arg_fail(7)) SWIG_fail;
10332 }
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 {
10342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10343 }
10344 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10345 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10346 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10347 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10348 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10349 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj;
10358 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10359 unsigned long arg2 ;
10360 unsigned long result;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char *kwnames[] = {
10364 (char *) "self",(char *) "key", NULL
10365 };
10366
10367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10369 if (SWIG_arg_fail(1)) SWIG_fail;
10370 {
10371 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10372 if (SWIG_arg_fail(2)) SWIG_fail;
10373 }
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10377
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 {
10382 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10383 }
10384 return resultobj;
10385 fail:
10386 return NULL;
10387 }
10388
10389
10390 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10391 PyObject *resultobj;
10392 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10393 unsigned char arg2 ;
10394 unsigned char arg3 ;
10395 unsigned char arg4 ;
10396 unsigned long result;
10397 PyObject * obj0 = 0 ;
10398 PyObject * obj1 = 0 ;
10399 PyObject * obj2 = 0 ;
10400 PyObject * obj3 = 0 ;
10401 char *kwnames[] = {
10402 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10403 };
10404
10405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10407 if (SWIG_arg_fail(1)) SWIG_fail;
10408 {
10409 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10410 if (SWIG_arg_fail(2)) SWIG_fail;
10411 }
10412 {
10413 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10414 if (SWIG_arg_fail(3)) SWIG_fail;
10415 }
10416 {
10417 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10418 if (SWIG_arg_fail(4)) SWIG_fail;
10419 }
10420 {
10421 PyThreadState* __tstate = wxPyBeginAllowThreads();
10422 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10423
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 {
10428 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10429 }
10430 return resultobj;
10431 fail:
10432 return NULL;
10433 }
10434
10435
10436 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10437 PyObject *resultobj;
10438 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10439 wxColour *arg2 = 0 ;
10440 unsigned long result;
10441 wxColour temp2 ;
10442 PyObject * obj0 = 0 ;
10443 PyObject * obj1 = 0 ;
10444 char *kwnames[] = {
10445 (char *) "self",(char *) "colour", NULL
10446 };
10447
10448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10450 if (SWIG_arg_fail(1)) SWIG_fail;
10451 {
10452 arg2 = &temp2;
10453 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10454 }
10455 {
10456 PyThreadState* __tstate = wxPyBeginAllowThreads();
10457 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10458
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 {
10463 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10464 }
10465 return resultobj;
10466 fail:
10467 return NULL;
10468 }
10469
10470
10471 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10472 PyObject *obj;
10473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10474 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10475 Py_INCREF(obj);
10476 return Py_BuildValue((char *)"");
10477 }
10478 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10479 PyObject *resultobj;
10480 wxString *arg1 = 0 ;
10481 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10482 int arg3 = (int) -1 ;
10483 wxImage *result;
10484 bool temp1 = false ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 PyObject * obj2 = 0 ;
10488 char *kwnames[] = {
10489 (char *) "name",(char *) "type",(char *) "index", NULL
10490 };
10491
10492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10493 {
10494 arg1 = wxString_in_helper(obj0);
10495 if (arg1 == NULL) SWIG_fail;
10496 temp1 = true;
10497 }
10498 if (obj1) {
10499 {
10500 arg2 = (long)(SWIG_As_long(obj1));
10501 if (SWIG_arg_fail(2)) SWIG_fail;
10502 }
10503 }
10504 if (obj2) {
10505 {
10506 arg3 = (int)(SWIG_As_int(obj2));
10507 if (SWIG_arg_fail(3)) SWIG_fail;
10508 }
10509 }
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10513
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 return resultobj;
10523 fail:
10524 {
10525 if (temp1)
10526 delete arg1;
10527 }
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxImage *arg1 = (wxImage *) 0 ;
10535 PyObject * obj0 = 0 ;
10536 char *kwnames[] = {
10537 (char *) "self", NULL
10538 };
10539
10540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10542 if (SWIG_arg_fail(1)) SWIG_fail;
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 delete arg1;
10546
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 Py_INCREF(Py_None); resultobj = Py_None;
10551 return resultobj;
10552 fail:
10553 return NULL;
10554 }
10555
10556
10557 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10558 PyObject *resultobj;
10559 wxString *arg1 = 0 ;
10560 wxString *arg2 = 0 ;
10561 int arg3 = (int) -1 ;
10562 wxImage *result;
10563 bool temp1 = false ;
10564 bool temp2 = false ;
10565 PyObject * obj0 = 0 ;
10566 PyObject * obj1 = 0 ;
10567 PyObject * obj2 = 0 ;
10568 char *kwnames[] = {
10569 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10570 };
10571
10572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10573 {
10574 arg1 = wxString_in_helper(obj0);
10575 if (arg1 == NULL) SWIG_fail;
10576 temp1 = true;
10577 }
10578 {
10579 arg2 = wxString_in_helper(obj1);
10580 if (arg2 == NULL) SWIG_fail;
10581 temp2 = true;
10582 }
10583 if (obj2) {
10584 {
10585 arg3 = (int)(SWIG_As_int(obj2));
10586 if (SWIG_arg_fail(3)) SWIG_fail;
10587 }
10588 }
10589 {
10590 PyThreadState* __tstate = wxPyBeginAllowThreads();
10591 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10592
10593 wxPyEndAllowThreads(__tstate);
10594 if (PyErr_Occurred()) SWIG_fail;
10595 }
10596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10597 {
10598 if (temp1)
10599 delete arg1;
10600 }
10601 {
10602 if (temp2)
10603 delete arg2;
10604 }
10605 return resultobj;
10606 fail:
10607 {
10608 if (temp1)
10609 delete arg1;
10610 }
10611 {
10612 if (temp2)
10613 delete arg2;
10614 }
10615 return NULL;
10616 }
10617
10618
10619 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxInputStream *arg1 = 0 ;
10622 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10623 int arg3 = (int) -1 ;
10624 wxImage *result;
10625 wxPyInputStream *temp1 ;
10626 bool created1 ;
10627 PyObject * obj0 = 0 ;
10628 PyObject * obj1 = 0 ;
10629 PyObject * obj2 = 0 ;
10630 char *kwnames[] = {
10631 (char *) "stream",(char *) "type",(char *) "index", NULL
10632 };
10633
10634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10635 {
10636 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10637 arg1 = temp1->m_wxis;
10638 created1 = false;
10639 } else {
10640 PyErr_Clear(); // clear the failure of the wxPyConvert above
10641 arg1 = wxPyCBInputStream_create(obj0, false);
10642 if (arg1 == NULL) {
10643 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10644 SWIG_fail;
10645 }
10646 created1 = true;
10647 }
10648 }
10649 if (obj1) {
10650 {
10651 arg2 = (long)(SWIG_As_long(obj1));
10652 if (SWIG_arg_fail(2)) SWIG_fail;
10653 }
10654 }
10655 if (obj2) {
10656 {
10657 arg3 = (int)(SWIG_As_int(obj2));
10658 if (SWIG_arg_fail(3)) SWIG_fail;
10659 }
10660 }
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10664
10665 wxPyEndAllowThreads(__tstate);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10669 {
10670 if (created1) delete arg1;
10671 }
10672 return resultobj;
10673 fail:
10674 {
10675 if (created1) delete arg1;
10676 }
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxInputStream *arg1 = 0 ;
10684 wxString *arg2 = 0 ;
10685 int arg3 = (int) -1 ;
10686 wxImage *result;
10687 wxPyInputStream *temp1 ;
10688 bool created1 ;
10689 bool temp2 = false ;
10690 PyObject * obj0 = 0 ;
10691 PyObject * obj1 = 0 ;
10692 PyObject * obj2 = 0 ;
10693 char *kwnames[] = {
10694 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10695 };
10696
10697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10698 {
10699 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10700 arg1 = temp1->m_wxis;
10701 created1 = false;
10702 } else {
10703 PyErr_Clear(); // clear the failure of the wxPyConvert above
10704 arg1 = wxPyCBInputStream_create(obj0, false);
10705 if (arg1 == NULL) {
10706 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10707 SWIG_fail;
10708 }
10709 created1 = true;
10710 }
10711 }
10712 {
10713 arg2 = wxString_in_helper(obj1);
10714 if (arg2 == NULL) SWIG_fail;
10715 temp2 = true;
10716 }
10717 if (obj2) {
10718 {
10719 arg3 = (int)(SWIG_As_int(obj2));
10720 if (SWIG_arg_fail(3)) SWIG_fail;
10721 }
10722 }
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10726
10727 wxPyEndAllowThreads(__tstate);
10728 if (PyErr_Occurred()) SWIG_fail;
10729 }
10730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10731 {
10732 if (created1) delete arg1;
10733 }
10734 {
10735 if (temp2)
10736 delete arg2;
10737 }
10738 return resultobj;
10739 fail:
10740 {
10741 if (created1) delete arg1;
10742 }
10743 {
10744 if (temp2)
10745 delete arg2;
10746 }
10747 return NULL;
10748 }
10749
10750
10751 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj;
10753 int arg1 = (int) 0 ;
10754 int arg2 = (int) 0 ;
10755 bool arg3 = (bool) true ;
10756 wxImage *result;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 PyObject * obj2 = 0 ;
10760 char *kwnames[] = {
10761 (char *) "width",(char *) "height",(char *) "clear", NULL
10762 };
10763
10764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10765 if (obj0) {
10766 {
10767 arg1 = (int)(SWIG_As_int(obj0));
10768 if (SWIG_arg_fail(1)) SWIG_fail;
10769 }
10770 }
10771 if (obj1) {
10772 {
10773 arg2 = (int)(SWIG_As_int(obj1));
10774 if (SWIG_arg_fail(2)) SWIG_fail;
10775 }
10776 }
10777 if (obj2) {
10778 {
10779 arg3 = (bool)(SWIG_As_bool(obj2));
10780 if (SWIG_arg_fail(3)) SWIG_fail;
10781 }
10782 }
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10786
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10791 return resultobj;
10792 fail:
10793 return NULL;
10794 }
10795
10796
10797 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10798 PyObject *resultobj;
10799 wxBitmap *arg1 = 0 ;
10800 wxImage *result;
10801 PyObject * obj0 = 0 ;
10802 char *kwnames[] = {
10803 (char *) "bitmap", NULL
10804 };
10805
10806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10807 {
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 if (arg1 == NULL) {
10811 SWIG_null_ref("wxBitmap");
10812 }
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 }
10815 {
10816 if (!wxPyCheckForApp()) SWIG_fail;
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10831 PyObject *resultobj;
10832 int arg1 ;
10833 int arg2 ;
10834 buffer arg3 ;
10835 int arg4 ;
10836 wxImage *result;
10837 PyObject * obj0 = 0 ;
10838 PyObject * obj1 = 0 ;
10839 PyObject * obj2 = 0 ;
10840 char *kwnames[] = {
10841 (char *) "width",(char *) "height",(char *) "data", NULL
10842 };
10843
10844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10845 {
10846 arg1 = (int)(SWIG_As_int(obj0));
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 }
10849 {
10850 arg2 = (int)(SWIG_As_int(obj1));
10851 if (SWIG_arg_fail(2)) SWIG_fail;
10852 }
10853 {
10854 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10855 }
10856 {
10857 PyThreadState* __tstate = wxPyBeginAllowThreads();
10858 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10859
10860 wxPyEndAllowThreads(__tstate);
10861 if (PyErr_Occurred()) SWIG_fail;
10862 }
10863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj;
10872 int arg1 ;
10873 int arg2 ;
10874 buffer arg3 ;
10875 int arg4 ;
10876 buffer arg5 ;
10877 int arg6 ;
10878 wxImage *result;
10879 PyObject * obj0 = 0 ;
10880 PyObject * obj1 = 0 ;
10881 PyObject * obj2 = 0 ;
10882 PyObject * obj3 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10888 {
10889 arg1 = (int)(SWIG_As_int(obj0));
10890 if (SWIG_arg_fail(1)) SWIG_fail;
10891 }
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10898 }
10899 {
10900 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10901 }
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10905
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj;
10918 wxImage *arg1 = (wxImage *) 0 ;
10919 int arg2 ;
10920 int arg3 ;
10921 PyObject * obj0 = 0 ;
10922 PyObject * obj1 = 0 ;
10923 PyObject * obj2 = 0 ;
10924 char *kwnames[] = {
10925 (char *) "self",(char *) "width",(char *) "height", NULL
10926 };
10927
10928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10930 if (SWIG_arg_fail(1)) SWIG_fail;
10931 {
10932 arg2 = (int)(SWIG_As_int(obj1));
10933 if (SWIG_arg_fail(2)) SWIG_fail;
10934 }
10935 {
10936 arg3 = (int)(SWIG_As_int(obj2));
10937 if (SWIG_arg_fail(3)) SWIG_fail;
10938 }
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 (arg1)->Create(arg2,arg3);
10942
10943 wxPyEndAllowThreads(__tstate);
10944 if (PyErr_Occurred()) SWIG_fail;
10945 }
10946 Py_INCREF(Py_None); resultobj = Py_None;
10947 return resultobj;
10948 fail:
10949 return NULL;
10950 }
10951
10952
10953 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj;
10955 wxImage *arg1 = (wxImage *) 0 ;
10956 PyObject * obj0 = 0 ;
10957 char *kwnames[] = {
10958 (char *) "self", NULL
10959 };
10960
10961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10963 if (SWIG_arg_fail(1)) SWIG_fail;
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 (arg1)->Destroy();
10967
10968 wxPyEndAllowThreads(__tstate);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 Py_INCREF(Py_None); resultobj = Py_None;
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj;
10980 wxImage *arg1 = (wxImage *) 0 ;
10981 int arg2 ;
10982 int arg3 ;
10983 SwigValueWrapper<wxImage > result;
10984 PyObject * obj0 = 0 ;
10985 PyObject * obj1 = 0 ;
10986 PyObject * obj2 = 0 ;
10987 char *kwnames[] = {
10988 (char *) "self",(char *) "width",(char *) "height", NULL
10989 };
10990
10991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10993 if (SWIG_arg_fail(1)) SWIG_fail;
10994 {
10995 arg2 = (int)(SWIG_As_int(obj1));
10996 if (SWIG_arg_fail(2)) SWIG_fail;
10997 }
10998 {
10999 arg3 = (int)(SWIG_As_int(obj2));
11000 if (SWIG_arg_fail(3)) SWIG_fail;
11001 }
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = (arg1)->Scale(arg2,arg3);
11005
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 wxImage * resultptr;
11011 resultptr = new wxImage((wxImage &)(result));
11012 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11013 }
11014 return resultobj;
11015 fail:
11016 return NULL;
11017 }
11018
11019
11020 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11021 PyObject *resultobj;
11022 wxImage *arg1 = (wxImage *) 0 ;
11023 int arg2 ;
11024 int arg3 ;
11025 SwigValueWrapper<wxImage > result;
11026 PyObject * obj0 = 0 ;
11027 PyObject * obj1 = 0 ;
11028 PyObject * obj2 = 0 ;
11029 char *kwnames[] = {
11030 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11031 };
11032
11033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11035 if (SWIG_arg_fail(1)) SWIG_fail;
11036 {
11037 arg2 = (int)(SWIG_As_int(obj1));
11038 if (SWIG_arg_fail(2)) SWIG_fail;
11039 }
11040 {
11041 arg3 = (int)(SWIG_As_int(obj2));
11042 if (SWIG_arg_fail(3)) SWIG_fail;
11043 }
11044 {
11045 PyThreadState* __tstate = wxPyBeginAllowThreads();
11046 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11047
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 {
11052 wxImage * resultptr;
11053 resultptr = new wxImage((wxImage &)(result));
11054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11055 }
11056 return resultobj;
11057 fail:
11058 return NULL;
11059 }
11060
11061
11062 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11063 PyObject *resultobj;
11064 wxImage *arg1 = (wxImage *) 0 ;
11065 int arg2 ;
11066 int arg3 ;
11067 wxImage *result;
11068 PyObject * obj0 = 0 ;
11069 PyObject * obj1 = 0 ;
11070 PyObject * obj2 = 0 ;
11071 char *kwnames[] = {
11072 (char *) "self",(char *) "width",(char *) "height", NULL
11073 };
11074
11075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11077 if (SWIG_arg_fail(1)) SWIG_fail;
11078 {
11079 arg2 = (int)(SWIG_As_int(obj1));
11080 if (SWIG_arg_fail(2)) SWIG_fail;
11081 }
11082 {
11083 arg3 = (int)(SWIG_As_int(obj2));
11084 if (SWIG_arg_fail(3)) SWIG_fail;
11085 }
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 {
11089 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11090 result = (wxImage *) &_result_ref;
11091 }
11092
11093 wxPyEndAllowThreads(__tstate);
11094 if (PyErr_Occurred()) SWIG_fail;
11095 }
11096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11097 return resultobj;
11098 fail:
11099 return NULL;
11100 }
11101
11102
11103 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11104 PyObject *resultobj;
11105 wxImage *arg1 = (wxImage *) 0 ;
11106 wxSize *arg2 = 0 ;
11107 wxPoint *arg3 = 0 ;
11108 int arg4 = (int) -1 ;
11109 int arg5 = (int) -1 ;
11110 int arg6 = (int) -1 ;
11111 wxImage *result;
11112 wxSize temp2 ;
11113 wxPoint temp3 ;
11114 PyObject * obj0 = 0 ;
11115 PyObject * obj1 = 0 ;
11116 PyObject * obj2 = 0 ;
11117 PyObject * obj3 = 0 ;
11118 PyObject * obj4 = 0 ;
11119 PyObject * obj5 = 0 ;
11120 char *kwnames[] = {
11121 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11122 };
11123
11124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11126 if (SWIG_arg_fail(1)) SWIG_fail;
11127 {
11128 arg2 = &temp2;
11129 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11130 }
11131 {
11132 arg3 = &temp3;
11133 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11134 }
11135 if (obj3) {
11136 {
11137 arg4 = (int)(SWIG_As_int(obj3));
11138 if (SWIG_arg_fail(4)) SWIG_fail;
11139 }
11140 }
11141 if (obj4) {
11142 {
11143 arg5 = (int)(SWIG_As_int(obj4));
11144 if (SWIG_arg_fail(5)) SWIG_fail;
11145 }
11146 }
11147 if (obj5) {
11148 {
11149 arg6 = (int)(SWIG_As_int(obj5));
11150 if (SWIG_arg_fail(6)) SWIG_fail;
11151 }
11152 }
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 {
11156 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11157 result = (wxImage *) &_result_ref;
11158 }
11159
11160 wxPyEndAllowThreads(__tstate);
11161 if (PyErr_Occurred()) SWIG_fail;
11162 }
11163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11164 return resultobj;
11165 fail:
11166 return NULL;
11167 }
11168
11169
11170 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11171 PyObject *resultobj;
11172 wxImage *arg1 = (wxImage *) 0 ;
11173 int arg2 ;
11174 int arg3 ;
11175 unsigned char arg4 ;
11176 unsigned char arg5 ;
11177 unsigned char arg6 ;
11178 PyObject * obj0 = 0 ;
11179 PyObject * obj1 = 0 ;
11180 PyObject * obj2 = 0 ;
11181 PyObject * obj3 = 0 ;
11182 PyObject * obj4 = 0 ;
11183 PyObject * obj5 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 arg2 = (int)(SWIG_As_int(obj1));
11193 if (SWIG_arg_fail(2)) SWIG_fail;
11194 }
11195 {
11196 arg3 = (int)(SWIG_As_int(obj2));
11197 if (SWIG_arg_fail(3)) SWIG_fail;
11198 }
11199 {
11200 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11201 if (SWIG_arg_fail(4)) SWIG_fail;
11202 }
11203 {
11204 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11205 if (SWIG_arg_fail(5)) SWIG_fail;
11206 }
11207 {
11208 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11209 if (SWIG_arg_fail(6)) SWIG_fail;
11210 }
11211 {
11212 PyThreadState* __tstate = wxPyBeginAllowThreads();
11213 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11214
11215 wxPyEndAllowThreads(__tstate);
11216 if (PyErr_Occurred()) SWIG_fail;
11217 }
11218 Py_INCREF(Py_None); resultobj = Py_None;
11219 return resultobj;
11220 fail:
11221 return NULL;
11222 }
11223
11224
11225 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11226 PyObject *resultobj;
11227 wxImage *arg1 = (wxImage *) 0 ;
11228 wxRect *arg2 = 0 ;
11229 unsigned char arg3 ;
11230 unsigned char arg4 ;
11231 unsigned char arg5 ;
11232 wxRect temp2 ;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236 PyObject * obj3 = 0 ;
11237 PyObject * obj4 = 0 ;
11238 char *kwnames[] = {
11239 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11240 };
11241
11242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11244 if (SWIG_arg_fail(1)) SWIG_fail;
11245 {
11246 arg2 = &temp2;
11247 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11248 }
11249 {
11250 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11251 if (SWIG_arg_fail(3)) SWIG_fail;
11252 }
11253 {
11254 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11255 if (SWIG_arg_fail(4)) SWIG_fail;
11256 }
11257 {
11258 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11259 if (SWIG_arg_fail(5)) SWIG_fail;
11260 }
11261 {
11262 PyThreadState* __tstate = wxPyBeginAllowThreads();
11263 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11264
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 Py_INCREF(Py_None); resultobj = Py_None;
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj;
11277 wxImage *arg1 = (wxImage *) 0 ;
11278 int arg2 ;
11279 int arg3 ;
11280 unsigned char result;
11281 PyObject * obj0 = 0 ;
11282 PyObject * obj1 = 0 ;
11283 PyObject * obj2 = 0 ;
11284 char *kwnames[] = {
11285 (char *) "self",(char *) "x",(char *) "y", NULL
11286 };
11287
11288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11290 if (SWIG_arg_fail(1)) SWIG_fail;
11291 {
11292 arg2 = (int)(SWIG_As_int(obj1));
11293 if (SWIG_arg_fail(2)) SWIG_fail;
11294 }
11295 {
11296 arg3 = (int)(SWIG_As_int(obj2));
11297 if (SWIG_arg_fail(3)) SWIG_fail;
11298 }
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11302
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11308 }
11309 return resultobj;
11310 fail:
11311 return NULL;
11312 }
11313
11314
11315 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj;
11317 wxImage *arg1 = (wxImage *) 0 ;
11318 int arg2 ;
11319 int arg3 ;
11320 unsigned char result;
11321 PyObject * obj0 = 0 ;
11322 PyObject * obj1 = 0 ;
11323 PyObject * obj2 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "self",(char *) "x",(char *) "y", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11330 if (SWIG_arg_fail(1)) SWIG_fail;
11331 {
11332 arg2 = (int)(SWIG_As_int(obj1));
11333 if (SWIG_arg_fail(2)) SWIG_fail;
11334 }
11335 {
11336 arg3 = (int)(SWIG_As_int(obj2));
11337 if (SWIG_arg_fail(3)) SWIG_fail;
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11342
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 {
11347 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11348 }
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj;
11357 wxImage *arg1 = (wxImage *) 0 ;
11358 int arg2 ;
11359 int arg3 ;
11360 unsigned char result;
11361 PyObject * obj0 = 0 ;
11362 PyObject * obj1 = 0 ;
11363 PyObject * obj2 = 0 ;
11364 char *kwnames[] = {
11365 (char *) "self",(char *) "x",(char *) "y", NULL
11366 };
11367
11368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11370 if (SWIG_arg_fail(1)) SWIG_fail;
11371 {
11372 arg2 = (int)(SWIG_As_int(obj1));
11373 if (SWIG_arg_fail(2)) SWIG_fail;
11374 }
11375 {
11376 arg3 = (int)(SWIG_As_int(obj2));
11377 if (SWIG_arg_fail(3)) SWIG_fail;
11378 }
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11382
11383 wxPyEndAllowThreads(__tstate);
11384 if (PyErr_Occurred()) SWIG_fail;
11385 }
11386 {
11387 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11388 }
11389 return resultobj;
11390 fail:
11391 return NULL;
11392 }
11393
11394
11395 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11396 PyObject *resultobj;
11397 wxImage *arg1 = (wxImage *) 0 ;
11398 int arg2 ;
11399 int arg3 ;
11400 unsigned char arg4 ;
11401 PyObject * obj0 = 0 ;
11402 PyObject * obj1 = 0 ;
11403 PyObject * obj2 = 0 ;
11404 PyObject * obj3 = 0 ;
11405 char *kwnames[] = {
11406 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11407 };
11408
11409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11411 if (SWIG_arg_fail(1)) SWIG_fail;
11412 {
11413 arg2 = (int)(SWIG_As_int(obj1));
11414 if (SWIG_arg_fail(2)) SWIG_fail;
11415 }
11416 {
11417 arg3 = (int)(SWIG_As_int(obj2));
11418 if (SWIG_arg_fail(3)) SWIG_fail;
11419 }
11420 {
11421 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11422 if (SWIG_arg_fail(4)) SWIG_fail;
11423 }
11424 {
11425 PyThreadState* __tstate = wxPyBeginAllowThreads();
11426 (arg1)->SetAlpha(arg2,arg3,arg4);
11427
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 Py_INCREF(Py_None); resultobj = Py_None;
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj;
11440 wxImage *arg1 = (wxImage *) 0 ;
11441 int arg2 ;
11442 int arg3 ;
11443 unsigned char result;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 PyObject * obj2 = 0 ;
11447 char *kwnames[] = {
11448 (char *) "self",(char *) "x",(char *) "y", NULL
11449 };
11450
11451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11453 if (SWIG_arg_fail(1)) SWIG_fail;
11454 {
11455 arg2 = (int)(SWIG_As_int(obj1));
11456 if (SWIG_arg_fail(2)) SWIG_fail;
11457 }
11458 {
11459 arg3 = (int)(SWIG_As_int(obj2));
11460 if (SWIG_arg_fail(3)) SWIG_fail;
11461 }
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11465
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 {
11470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11471 }
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11479 PyObject *resultobj;
11480 wxImage *arg1 = (wxImage *) 0 ;
11481 bool result;
11482 PyObject * obj0 = 0 ;
11483 char *kwnames[] = {
11484 (char *) "self", NULL
11485 };
11486
11487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11489 if (SWIG_arg_fail(1)) SWIG_fail;
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 result = (bool)(arg1)->HasAlpha();
11493
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 {
11498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11499 }
11500 return resultobj;
11501 fail:
11502 return NULL;
11503 }
11504
11505
11506 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj;
11508 wxImage *arg1 = (wxImage *) 0 ;
11509 PyObject * obj0 = 0 ;
11510 char *kwnames[] = {
11511 (char *) "self", NULL
11512 };
11513
11514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11516 if (SWIG_arg_fail(1)) SWIG_fail;
11517 {
11518 PyThreadState* __tstate = wxPyBeginAllowThreads();
11519 (arg1)->InitAlpha();
11520
11521 wxPyEndAllowThreads(__tstate);
11522 if (PyErr_Occurred()) SWIG_fail;
11523 }
11524 Py_INCREF(Py_None); resultobj = Py_None;
11525 return resultobj;
11526 fail:
11527 return NULL;
11528 }
11529
11530
11531 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11532 PyObject *resultobj;
11533 wxImage *arg1 = (wxImage *) 0 ;
11534 int arg2 ;
11535 int arg3 ;
11536 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11537 bool result;
11538 PyObject * obj0 = 0 ;
11539 PyObject * obj1 = 0 ;
11540 PyObject * obj2 = 0 ;
11541 PyObject * obj3 = 0 ;
11542 char *kwnames[] = {
11543 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11544 };
11545
11546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11548 if (SWIG_arg_fail(1)) SWIG_fail;
11549 {
11550 arg2 = (int)(SWIG_As_int(obj1));
11551 if (SWIG_arg_fail(2)) SWIG_fail;
11552 }
11553 {
11554 arg3 = (int)(SWIG_As_int(obj2));
11555 if (SWIG_arg_fail(3)) SWIG_fail;
11556 }
11557 if (obj3) {
11558 {
11559 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11560 if (SWIG_arg_fail(4)) SWIG_fail;
11561 }
11562 }
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11566
11567 wxPyEndAllowThreads(__tstate);
11568 if (PyErr_Occurred()) SWIG_fail;
11569 }
11570 {
11571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11572 }
11573 return resultobj;
11574 fail:
11575 return NULL;
11576 }
11577
11578
11579 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11580 PyObject *resultobj;
11581 wxImage *arg1 = (wxImage *) 0 ;
11582 byte *arg2 = (byte *) 0 ;
11583 byte *arg3 = (byte *) 0 ;
11584 byte *arg4 = (byte *) 0 ;
11585 byte arg5 = (byte) 0 ;
11586 byte arg6 = (byte) 0 ;
11587 byte arg7 = (byte) 0 ;
11588 bool result;
11589 byte temp2 ;
11590 int res2 = 0 ;
11591 byte temp3 ;
11592 int res3 = 0 ;
11593 byte temp4 ;
11594 int res4 = 0 ;
11595 PyObject * obj0 = 0 ;
11596 PyObject * obj1 = 0 ;
11597 PyObject * obj2 = 0 ;
11598 PyObject * obj3 = 0 ;
11599 char *kwnames[] = {
11600 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11601 };
11602
11603 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11604 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11605 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 if (obj1) {
11610 {
11611 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11612 if (SWIG_arg_fail(5)) SWIG_fail;
11613 }
11614 }
11615 if (obj2) {
11616 {
11617 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11618 if (SWIG_arg_fail(6)) SWIG_fail;
11619 }
11620 }
11621 if (obj3) {
11622 {
11623 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11624 if (SWIG_arg_fail(7)) SWIG_fail;
11625 }
11626 }
11627 {
11628 PyThreadState* __tstate = wxPyBeginAllowThreads();
11629 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11630
11631 wxPyEndAllowThreads(__tstate);
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 {
11635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11636 }
11637 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11638 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11639 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11640 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11641 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11642 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11650 PyObject *resultobj;
11651 wxImage *arg1 = (wxImage *) 0 ;
11652 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11653 bool result;
11654 PyObject * obj0 = 0 ;
11655 PyObject * obj1 = 0 ;
11656 char *kwnames[] = {
11657 (char *) "self",(char *) "threshold", NULL
11658 };
11659
11660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11662 if (SWIG_arg_fail(1)) SWIG_fail;
11663 if (obj1) {
11664 {
11665 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11666 if (SWIG_arg_fail(2)) SWIG_fail;
11667 }
11668 }
11669 {
11670 PyThreadState* __tstate = wxPyBeginAllowThreads();
11671 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11672
11673 wxPyEndAllowThreads(__tstate);
11674 if (PyErr_Occurred()) SWIG_fail;
11675 }
11676 {
11677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11678 }
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11686 PyObject *resultobj;
11687 wxImage *arg1 = (wxImage *) 0 ;
11688 unsigned char arg2 ;
11689 unsigned char arg3 ;
11690 unsigned char arg4 ;
11691 bool result;
11692 PyObject * obj0 = 0 ;
11693 PyObject * obj1 = 0 ;
11694 PyObject * obj2 = 0 ;
11695 PyObject * obj3 = 0 ;
11696 char *kwnames[] = {
11697 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11698 };
11699
11700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11702 if (SWIG_arg_fail(1)) SWIG_fail;
11703 {
11704 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11705 if (SWIG_arg_fail(2)) SWIG_fail;
11706 }
11707 {
11708 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11709 if (SWIG_arg_fail(3)) SWIG_fail;
11710 }
11711 {
11712 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11713 if (SWIG_arg_fail(4)) SWIG_fail;
11714 }
11715 {
11716 PyThreadState* __tstate = wxPyBeginAllowThreads();
11717 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11718
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 {
11723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11724 }
11725 return resultobj;
11726 fail:
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 wxImage *arg1 = (wxImage *) 0 ;
11734 wxImage *arg2 = 0 ;
11735 byte arg3 ;
11736 byte arg4 ;
11737 byte arg5 ;
11738 bool result;
11739 PyObject * obj0 = 0 ;
11740 PyObject * obj1 = 0 ;
11741 PyObject * obj2 = 0 ;
11742 PyObject * obj3 = 0 ;
11743 PyObject * obj4 = 0 ;
11744 char *kwnames[] = {
11745 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11746 };
11747
11748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11750 if (SWIG_arg_fail(1)) SWIG_fail;
11751 {
11752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11753 if (SWIG_arg_fail(2)) SWIG_fail;
11754 if (arg2 == NULL) {
11755 SWIG_null_ref("wxImage");
11756 }
11757 if (SWIG_arg_fail(2)) SWIG_fail;
11758 }
11759 {
11760 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11761 if (SWIG_arg_fail(3)) SWIG_fail;
11762 }
11763 {
11764 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11765 if (SWIG_arg_fail(4)) SWIG_fail;
11766 }
11767 {
11768 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11769 if (SWIG_arg_fail(5)) SWIG_fail;
11770 }
11771 {
11772 PyThreadState* __tstate = wxPyBeginAllowThreads();
11773 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11774
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 {
11779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11780 }
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxString *arg1 = 0 ;
11790 bool result;
11791 bool temp1 = false ;
11792 PyObject * obj0 = 0 ;
11793 char *kwnames[] = {
11794 (char *) "name", NULL
11795 };
11796
11797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11798 {
11799 arg1 = wxString_in_helper(obj0);
11800 if (arg1 == NULL) SWIG_fail;
11801 temp1 = true;
11802 }
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11806
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 {
11811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11812 }
11813 {
11814 if (temp1)
11815 delete arg1;
11816 }
11817 return resultobj;
11818 fail:
11819 {
11820 if (temp1)
11821 delete arg1;
11822 }
11823 return NULL;
11824 }
11825
11826
11827 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11828 PyObject *resultobj;
11829 wxString *arg1 = 0 ;
11830 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11831 int result;
11832 bool temp1 = false ;
11833 PyObject * obj0 = 0 ;
11834 PyObject * obj1 = 0 ;
11835 char *kwnames[] = {
11836 (char *) "name",(char *) "type", NULL
11837 };
11838
11839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11840 {
11841 arg1 = wxString_in_helper(obj0);
11842 if (arg1 == NULL) SWIG_fail;
11843 temp1 = true;
11844 }
11845 if (obj1) {
11846 {
11847 arg2 = (long)(SWIG_As_long(obj1));
11848 if (SWIG_arg_fail(2)) SWIG_fail;
11849 }
11850 }
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11854
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 {
11859 resultobj = SWIG_From_int((int)(result));
11860 }
11861 {
11862 if (temp1)
11863 delete arg1;
11864 }
11865 return resultobj;
11866 fail:
11867 {
11868 if (temp1)
11869 delete arg1;
11870 }
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj;
11877 wxImage *arg1 = (wxImage *) 0 ;
11878 wxString *arg2 = 0 ;
11879 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11880 int arg4 = (int) -1 ;
11881 bool result;
11882 bool temp2 = false ;
11883 PyObject * obj0 = 0 ;
11884 PyObject * obj1 = 0 ;
11885 PyObject * obj2 = 0 ;
11886 PyObject * obj3 = 0 ;
11887 char *kwnames[] = {
11888 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11889 };
11890
11891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11893 if (SWIG_arg_fail(1)) SWIG_fail;
11894 {
11895 arg2 = wxString_in_helper(obj1);
11896 if (arg2 == NULL) SWIG_fail;
11897 temp2 = true;
11898 }
11899 if (obj2) {
11900 {
11901 arg3 = (long)(SWIG_As_long(obj2));
11902 if (SWIG_arg_fail(3)) SWIG_fail;
11903 }
11904 }
11905 if (obj3) {
11906 {
11907 arg4 = (int)(SWIG_As_int(obj3));
11908 if (SWIG_arg_fail(4)) SWIG_fail;
11909 }
11910 }
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11914
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 {
11919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11920 }
11921 {
11922 if (temp2)
11923 delete arg2;
11924 }
11925 return resultobj;
11926 fail:
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxImage *arg1 = (wxImage *) 0 ;
11938 wxString *arg2 = 0 ;
11939 wxString *arg3 = 0 ;
11940 int arg4 = (int) -1 ;
11941 bool result;
11942 bool temp2 = false ;
11943 bool temp3 = false ;
11944 PyObject * obj0 = 0 ;
11945 PyObject * obj1 = 0 ;
11946 PyObject * obj2 = 0 ;
11947 PyObject * obj3 = 0 ;
11948 char *kwnames[] = {
11949 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11950 };
11951
11952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11954 if (SWIG_arg_fail(1)) SWIG_fail;
11955 {
11956 arg2 = wxString_in_helper(obj1);
11957 if (arg2 == NULL) SWIG_fail;
11958 temp2 = true;
11959 }
11960 {
11961 arg3 = wxString_in_helper(obj2);
11962 if (arg3 == NULL) SWIG_fail;
11963 temp3 = true;
11964 }
11965 if (obj3) {
11966 {
11967 arg4 = (int)(SWIG_As_int(obj3));
11968 if (SWIG_arg_fail(4)) SWIG_fail;
11969 }
11970 }
11971 {
11972 PyThreadState* __tstate = wxPyBeginAllowThreads();
11973 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11974
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 {
11979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11980 }
11981 {
11982 if (temp2)
11983 delete arg2;
11984 }
11985 {
11986 if (temp3)
11987 delete arg3;
11988 }
11989 return resultobj;
11990 fail:
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 {
11996 if (temp3)
11997 delete arg3;
11998 }
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxImage *arg1 = (wxImage *) 0 ;
12006 wxString *arg2 = 0 ;
12007 int arg3 ;
12008 bool result;
12009 bool temp2 = false ;
12010 PyObject * obj0 = 0 ;
12011 PyObject * obj1 = 0 ;
12012 PyObject * obj2 = 0 ;
12013 char *kwnames[] = {
12014 (char *) "self",(char *) "name",(char *) "type", NULL
12015 };
12016
12017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12019 if (SWIG_arg_fail(1)) SWIG_fail;
12020 {
12021 arg2 = wxString_in_helper(obj1);
12022 if (arg2 == NULL) SWIG_fail;
12023 temp2 = true;
12024 }
12025 {
12026 arg3 = (int)(SWIG_As_int(obj2));
12027 if (SWIG_arg_fail(3)) SWIG_fail;
12028 }
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12038 }
12039 {
12040 if (temp2)
12041 delete arg2;
12042 }
12043 return resultobj;
12044 fail:
12045 {
12046 if (temp2)
12047 delete arg2;
12048 }
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxImage *arg1 = (wxImage *) 0 ;
12056 wxString *arg2 = 0 ;
12057 wxString *arg3 = 0 ;
12058 bool result;
12059 bool temp2 = false ;
12060 bool temp3 = false ;
12061 PyObject * obj0 = 0 ;
12062 PyObject * obj1 = 0 ;
12063 PyObject * obj2 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 arg2 = wxString_in_helper(obj1);
12073 if (arg2 == NULL) SWIG_fail;
12074 temp2 = true;
12075 }
12076 {
12077 arg3 = wxString_in_helper(obj2);
12078 if (arg3 == NULL) SWIG_fail;
12079 temp3 = true;
12080 }
12081 {
12082 PyThreadState* __tstate = wxPyBeginAllowThreads();
12083 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12084
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 {
12089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12090 }
12091 {
12092 if (temp2)
12093 delete arg2;
12094 }
12095 {
12096 if (temp3)
12097 delete arg3;
12098 }
12099 return resultobj;
12100 fail:
12101 {
12102 if (temp2)
12103 delete arg2;
12104 }
12105 {
12106 if (temp3)
12107 delete arg3;
12108 }
12109 return NULL;
12110 }
12111
12112
12113 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12114 PyObject *resultobj;
12115 wxInputStream *arg1 = 0 ;
12116 bool result;
12117 wxPyInputStream *temp1 ;
12118 bool created1 ;
12119 PyObject * obj0 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "stream", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12125 {
12126 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12127 arg1 = temp1->m_wxis;
12128 created1 = false;
12129 } else {
12130 PyErr_Clear(); // clear the failure of the wxPyConvert above
12131 arg1 = wxPyCBInputStream_create(obj0, false);
12132 if (arg1 == NULL) {
12133 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12134 SWIG_fail;
12135 }
12136 created1 = true;
12137 }
12138 }
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (bool)wxImage::CanRead(*arg1);
12142
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 {
12147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12148 }
12149 {
12150 if (created1) delete arg1;
12151 }
12152 return resultobj;
12153 fail:
12154 {
12155 if (created1) delete arg1;
12156 }
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxImage *arg1 = (wxImage *) 0 ;
12164 wxInputStream *arg2 = 0 ;
12165 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12166 int arg4 = (int) -1 ;
12167 bool result;
12168 wxPyInputStream *temp2 ;
12169 bool created2 ;
12170 PyObject * obj0 = 0 ;
12171 PyObject * obj1 = 0 ;
12172 PyObject * obj2 = 0 ;
12173 PyObject * obj3 = 0 ;
12174 char *kwnames[] = {
12175 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12176 };
12177
12178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12180 if (SWIG_arg_fail(1)) SWIG_fail;
12181 {
12182 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12183 arg2 = temp2->m_wxis;
12184 created2 = false;
12185 } else {
12186 PyErr_Clear(); // clear the failure of the wxPyConvert above
12187 arg2 = wxPyCBInputStream_create(obj1, false);
12188 if (arg2 == NULL) {
12189 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12190 SWIG_fail;
12191 }
12192 created2 = true;
12193 }
12194 }
12195 if (obj2) {
12196 {
12197 arg3 = (long)(SWIG_As_long(obj2));
12198 if (SWIG_arg_fail(3)) SWIG_fail;
12199 }
12200 }
12201 if (obj3) {
12202 {
12203 arg4 = (int)(SWIG_As_int(obj3));
12204 if (SWIG_arg_fail(4)) SWIG_fail;
12205 }
12206 }
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 {
12215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12216 }
12217 {
12218 if (created2) delete arg2;
12219 }
12220 return resultobj;
12221 fail:
12222 {
12223 if (created2) delete arg2;
12224 }
12225 return NULL;
12226 }
12227
12228
12229 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj;
12231 wxImage *arg1 = (wxImage *) 0 ;
12232 wxInputStream *arg2 = 0 ;
12233 wxString *arg3 = 0 ;
12234 int arg4 = (int) -1 ;
12235 bool result;
12236 wxPyInputStream *temp2 ;
12237 bool created2 ;
12238 bool temp3 = false ;
12239 PyObject * obj0 = 0 ;
12240 PyObject * obj1 = 0 ;
12241 PyObject * obj2 = 0 ;
12242 PyObject * obj3 = 0 ;
12243 char *kwnames[] = {
12244 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12245 };
12246
12247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12249 if (SWIG_arg_fail(1)) SWIG_fail;
12250 {
12251 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12252 arg2 = temp2->m_wxis;
12253 created2 = false;
12254 } else {
12255 PyErr_Clear(); // clear the failure of the wxPyConvert above
12256 arg2 = wxPyCBInputStream_create(obj1, false);
12257 if (arg2 == NULL) {
12258 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12259 SWIG_fail;
12260 }
12261 created2 = true;
12262 }
12263 }
12264 {
12265 arg3 = wxString_in_helper(obj2);
12266 if (arg3 == NULL) SWIG_fail;
12267 temp3 = true;
12268 }
12269 if (obj3) {
12270 {
12271 arg4 = (int)(SWIG_As_int(obj3));
12272 if (SWIG_arg_fail(4)) SWIG_fail;
12273 }
12274 }
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12278
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 {
12283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12284 }
12285 {
12286 if (created2) delete arg2;
12287 }
12288 {
12289 if (temp3)
12290 delete arg3;
12291 }
12292 return resultobj;
12293 fail:
12294 {
12295 if (created2) delete arg2;
12296 }
12297 {
12298 if (temp3)
12299 delete arg3;
12300 }
12301 return NULL;
12302 }
12303
12304
12305 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj;
12307 wxImage *arg1 = (wxImage *) 0 ;
12308 bool result;
12309 PyObject * obj0 = 0 ;
12310 char *kwnames[] = {
12311 (char *) "self", NULL
12312 };
12313
12314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12316 if (SWIG_arg_fail(1)) SWIG_fail;
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 result = (bool)(arg1)->Ok();
12320
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 {
12325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12326 }
12327 return resultobj;
12328 fail:
12329 return NULL;
12330 }
12331
12332
12333 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12334 PyObject *resultobj;
12335 wxImage *arg1 = (wxImage *) 0 ;
12336 int result;
12337 PyObject * obj0 = 0 ;
12338 char *kwnames[] = {
12339 (char *) "self", NULL
12340 };
12341
12342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12344 if (SWIG_arg_fail(1)) SWIG_fail;
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = (int)(arg1)->GetWidth();
12348
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 {
12353 resultobj = SWIG_From_int((int)(result));
12354 }
12355 return resultobj;
12356 fail:
12357 return NULL;
12358 }
12359
12360
12361 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12362 PyObject *resultobj;
12363 wxImage *arg1 = (wxImage *) 0 ;
12364 int result;
12365 PyObject * obj0 = 0 ;
12366 char *kwnames[] = {
12367 (char *) "self", NULL
12368 };
12369
12370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12372 if (SWIG_arg_fail(1)) SWIG_fail;
12373 {
12374 PyThreadState* __tstate = wxPyBeginAllowThreads();
12375 result = (int)(arg1)->GetHeight();
12376
12377 wxPyEndAllowThreads(__tstate);
12378 if (PyErr_Occurred()) SWIG_fail;
12379 }
12380 {
12381 resultobj = SWIG_From_int((int)(result));
12382 }
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12390 PyObject *resultobj;
12391 wxImage *arg1 = (wxImage *) 0 ;
12392 wxSize result;
12393 PyObject * obj0 = 0 ;
12394 char *kwnames[] = {
12395 (char *) "self", NULL
12396 };
12397
12398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12400 if (SWIG_arg_fail(1)) SWIG_fail;
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = wxImage_GetSize(arg1);
12404
12405 wxPyEndAllowThreads(__tstate);
12406 if (PyErr_Occurred()) SWIG_fail;
12407 }
12408 {
12409 wxSize * resultptr;
12410 resultptr = new wxSize((wxSize &)(result));
12411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12412 }
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12420 PyObject *resultobj;
12421 wxImage *arg1 = (wxImage *) 0 ;
12422 wxRect *arg2 = 0 ;
12423 SwigValueWrapper<wxImage > result;
12424 wxRect temp2 ;
12425 PyObject * obj0 = 0 ;
12426 PyObject * obj1 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self",(char *) "rect", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 arg2 = &temp2;
12436 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12437 }
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12441
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 wxImage * resultptr;
12447 resultptr = new wxImage((wxImage &)(result));
12448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12449 }
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj;
12458 wxImage *arg1 = (wxImage *) 0 ;
12459 wxSize *arg2 = 0 ;
12460 wxPoint *arg3 = 0 ;
12461 int arg4 = (int) -1 ;
12462 int arg5 = (int) -1 ;
12463 int arg6 = (int) -1 ;
12464 SwigValueWrapper<wxImage > result;
12465 wxSize temp2 ;
12466 wxPoint temp3 ;
12467 PyObject * obj0 = 0 ;
12468 PyObject * obj1 = 0 ;
12469 PyObject * obj2 = 0 ;
12470 PyObject * obj3 = 0 ;
12471 PyObject * obj4 = 0 ;
12472 PyObject * obj5 = 0 ;
12473 char *kwnames[] = {
12474 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12475 };
12476
12477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12479 if (SWIG_arg_fail(1)) SWIG_fail;
12480 {
12481 arg2 = &temp2;
12482 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12483 }
12484 {
12485 arg3 = &temp3;
12486 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12487 }
12488 if (obj3) {
12489 {
12490 arg4 = (int)(SWIG_As_int(obj3));
12491 if (SWIG_arg_fail(4)) SWIG_fail;
12492 }
12493 }
12494 if (obj4) {
12495 {
12496 arg5 = (int)(SWIG_As_int(obj4));
12497 if (SWIG_arg_fail(5)) SWIG_fail;
12498 }
12499 }
12500 if (obj5) {
12501 {
12502 arg6 = (int)(SWIG_As_int(obj5));
12503 if (SWIG_arg_fail(6)) SWIG_fail;
12504 }
12505 }
12506 {
12507 PyThreadState* __tstate = wxPyBeginAllowThreads();
12508 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12509
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 {
12514 wxImage * resultptr;
12515 resultptr = new wxImage((wxImage &)(result));
12516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12517 }
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12525 PyObject *resultobj;
12526 wxImage *arg1 = (wxImage *) 0 ;
12527 SwigValueWrapper<wxImage > result;
12528 PyObject * obj0 = 0 ;
12529 char *kwnames[] = {
12530 (char *) "self", NULL
12531 };
12532
12533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12535 if (SWIG_arg_fail(1)) SWIG_fail;
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 result = (arg1)->Copy();
12539
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 {
12544 wxImage * resultptr;
12545 resultptr = new wxImage((wxImage &)(result));
12546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj;
12556 wxImage *arg1 = (wxImage *) 0 ;
12557 wxImage *arg2 = 0 ;
12558 int arg3 ;
12559 int arg4 ;
12560 PyObject * obj0 = 0 ;
12561 PyObject * obj1 = 0 ;
12562 PyObject * obj2 = 0 ;
12563 PyObject * obj3 = 0 ;
12564 char *kwnames[] = {
12565 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12566 };
12567
12568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12570 if (SWIG_arg_fail(1)) SWIG_fail;
12571 {
12572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12573 if (SWIG_arg_fail(2)) SWIG_fail;
12574 if (arg2 == NULL) {
12575 SWIG_null_ref("wxImage");
12576 }
12577 if (SWIG_arg_fail(2)) SWIG_fail;
12578 }
12579 {
12580 arg3 = (int)(SWIG_As_int(obj2));
12581 if (SWIG_arg_fail(3)) SWIG_fail;
12582 }
12583 {
12584 arg4 = (int)(SWIG_As_int(obj3));
12585 if (SWIG_arg_fail(4)) SWIG_fail;
12586 }
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12590
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 Py_INCREF(Py_None); resultobj = Py_None;
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj;
12603 wxImage *arg1 = (wxImage *) 0 ;
12604 PyObject *result;
12605 PyObject * obj0 = 0 ;
12606 char *kwnames[] = {
12607 (char *) "self", NULL
12608 };
12609
12610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12612 if (SWIG_arg_fail(1)) SWIG_fail;
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 result = (PyObject *)wxImage_GetData(arg1);
12616
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 resultobj = result;
12621 return resultobj;
12622 fail:
12623 return NULL;
12624 }
12625
12626
12627 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12628 PyObject *resultobj;
12629 wxImage *arg1 = (wxImage *) 0 ;
12630 buffer arg2 ;
12631 int arg3 ;
12632 PyObject * obj0 = 0 ;
12633 PyObject * obj1 = 0 ;
12634 char *kwnames[] = {
12635 (char *) "self",(char *) "data", NULL
12636 };
12637
12638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12640 if (SWIG_arg_fail(1)) SWIG_fail;
12641 {
12642 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 wxImage_SetData(arg1,arg2,arg3);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 Py_INCREF(Py_None); resultobj = Py_None;
12652 return resultobj;
12653 fail:
12654 return NULL;
12655 }
12656
12657
12658 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12659 PyObject *resultobj;
12660 wxImage *arg1 = (wxImage *) 0 ;
12661 PyObject *result;
12662 PyObject * obj0 = 0 ;
12663 char *kwnames[] = {
12664 (char *) "self", NULL
12665 };
12666
12667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12669 if (SWIG_arg_fail(1)) SWIG_fail;
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12673
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 resultobj = result;
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12685 PyObject *resultobj;
12686 wxImage *arg1 = (wxImage *) 0 ;
12687 buffer arg2 ;
12688 int arg3 ;
12689 PyObject * obj0 = 0 ;
12690 PyObject * obj1 = 0 ;
12691 char *kwnames[] = {
12692 (char *) "self",(char *) "data", NULL
12693 };
12694
12695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12697 if (SWIG_arg_fail(1)) SWIG_fail;
12698 {
12699 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12700 }
12701 {
12702 PyThreadState* __tstate = wxPyBeginAllowThreads();
12703 wxImage_SetDataBuffer(arg1,arg2,arg3);
12704
12705 wxPyEndAllowThreads(__tstate);
12706 if (PyErr_Occurred()) SWIG_fail;
12707 }
12708 Py_INCREF(Py_None); resultobj = Py_None;
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj;
12717 wxImage *arg1 = (wxImage *) 0 ;
12718 PyObject *result;
12719 PyObject * obj0 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 result = (PyObject *)wxImage_GetAlphaData(arg1);
12730
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 resultobj = result;
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxImage *arg1 = (wxImage *) 0 ;
12744 buffer arg2 ;
12745 int arg3 ;
12746 PyObject * obj0 = 0 ;
12747 PyObject * obj1 = 0 ;
12748 char *kwnames[] = {
12749 (char *) "self",(char *) "alpha", NULL
12750 };
12751
12752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12754 if (SWIG_arg_fail(1)) SWIG_fail;
12755 {
12756 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12757 }
12758 {
12759 PyThreadState* __tstate = wxPyBeginAllowThreads();
12760 wxImage_SetAlphaData(arg1,arg2,arg3);
12761
12762 wxPyEndAllowThreads(__tstate);
12763 if (PyErr_Occurred()) SWIG_fail;
12764 }
12765 Py_INCREF(Py_None); resultobj = Py_None;
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12773 PyObject *resultobj;
12774 wxImage *arg1 = (wxImage *) 0 ;
12775 PyObject *result;
12776 PyObject * obj0 = 0 ;
12777 char *kwnames[] = {
12778 (char *) "self", NULL
12779 };
12780
12781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12783 if (SWIG_arg_fail(1)) SWIG_fail;
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12787
12788 wxPyEndAllowThreads(__tstate);
12789 if (PyErr_Occurred()) SWIG_fail;
12790 }
12791 resultobj = result;
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12799 PyObject *resultobj;
12800 wxImage *arg1 = (wxImage *) 0 ;
12801 buffer arg2 ;
12802 int arg3 ;
12803 PyObject * obj0 = 0 ;
12804 PyObject * obj1 = 0 ;
12805 char *kwnames[] = {
12806 (char *) "self",(char *) "alpha", NULL
12807 };
12808
12809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12811 if (SWIG_arg_fail(1)) SWIG_fail;
12812 {
12813 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12814 }
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12818
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 Py_INCREF(Py_None); resultobj = Py_None;
12823 return resultobj;
12824 fail:
12825 return NULL;
12826 }
12827
12828
12829 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12830 PyObject *resultobj;
12831 wxImage *arg1 = (wxImage *) 0 ;
12832 unsigned char arg2 ;
12833 unsigned char arg3 ;
12834 unsigned char arg4 ;
12835 PyObject * obj0 = 0 ;
12836 PyObject * obj1 = 0 ;
12837 PyObject * obj2 = 0 ;
12838 PyObject * obj3 = 0 ;
12839 char *kwnames[] = {
12840 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12841 };
12842
12843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12845 if (SWIG_arg_fail(1)) SWIG_fail;
12846 {
12847 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12848 if (SWIG_arg_fail(2)) SWIG_fail;
12849 }
12850 {
12851 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12852 if (SWIG_arg_fail(3)) SWIG_fail;
12853 }
12854 {
12855 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12856 if (SWIG_arg_fail(4)) SWIG_fail;
12857 }
12858 {
12859 PyThreadState* __tstate = wxPyBeginAllowThreads();
12860 (arg1)->SetMaskColour(arg2,arg3,arg4);
12861
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 Py_INCREF(Py_None); resultobj = Py_None;
12866 return resultobj;
12867 fail:
12868 return NULL;
12869 }
12870
12871
12872 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12873 PyObject *resultobj;
12874 wxImage *arg1 = (wxImage *) 0 ;
12875 unsigned char *arg2 = (unsigned char *) 0 ;
12876 unsigned char *arg3 = (unsigned char *) 0 ;
12877 unsigned char *arg4 = (unsigned char *) 0 ;
12878 unsigned char temp2 ;
12879 int res2 = 0 ;
12880 unsigned char temp3 ;
12881 int res3 = 0 ;
12882 unsigned char temp4 ;
12883 int res4 = 0 ;
12884 PyObject * obj0 = 0 ;
12885 char *kwnames[] = {
12886 (char *) "self", NULL
12887 };
12888
12889 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12890 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12891 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12894 if (SWIG_arg_fail(1)) SWIG_fail;
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12898
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 Py_INCREF(Py_None); resultobj = Py_None;
12903 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12904 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12905 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12906 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12907 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12908 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12909 return resultobj;
12910 fail:
12911 return NULL;
12912 }
12913
12914
12915 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj;
12917 wxImage *arg1 = (wxImage *) 0 ;
12918 unsigned char result;
12919 PyObject * obj0 = 0 ;
12920 char *kwnames[] = {
12921 (char *) "self", NULL
12922 };
12923
12924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12926 if (SWIG_arg_fail(1)) SWIG_fail;
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 result = (unsigned char)(arg1)->GetMaskRed();
12930
12931 wxPyEndAllowThreads(__tstate);
12932 if (PyErr_Occurred()) SWIG_fail;
12933 }
12934 {
12935 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12936 }
12937 return resultobj;
12938 fail:
12939 return NULL;
12940 }
12941
12942
12943 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12944 PyObject *resultobj;
12945 wxImage *arg1 = (wxImage *) 0 ;
12946 unsigned char result;
12947 PyObject * obj0 = 0 ;
12948 char *kwnames[] = {
12949 (char *) "self", NULL
12950 };
12951
12952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12954 if (SWIG_arg_fail(1)) SWIG_fail;
12955 {
12956 PyThreadState* __tstate = wxPyBeginAllowThreads();
12957 result = (unsigned char)(arg1)->GetMaskGreen();
12958
12959 wxPyEndAllowThreads(__tstate);
12960 if (PyErr_Occurred()) SWIG_fail;
12961 }
12962 {
12963 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12964 }
12965 return resultobj;
12966 fail:
12967 return NULL;
12968 }
12969
12970
12971 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12972 PyObject *resultobj;
12973 wxImage *arg1 = (wxImage *) 0 ;
12974 unsigned char result;
12975 PyObject * obj0 = 0 ;
12976 char *kwnames[] = {
12977 (char *) "self", NULL
12978 };
12979
12980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12982 if (SWIG_arg_fail(1)) SWIG_fail;
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (unsigned char)(arg1)->GetMaskBlue();
12986
12987 wxPyEndAllowThreads(__tstate);
12988 if (PyErr_Occurred()) SWIG_fail;
12989 }
12990 {
12991 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12992 }
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj;
13001 wxImage *arg1 = (wxImage *) 0 ;
13002 bool arg2 = (bool) true ;
13003 PyObject * obj0 = 0 ;
13004 PyObject * obj1 = 0 ;
13005 char *kwnames[] = {
13006 (char *) "self",(char *) "mask", NULL
13007 };
13008
13009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13011 if (SWIG_arg_fail(1)) SWIG_fail;
13012 if (obj1) {
13013 {
13014 arg2 = (bool)(SWIG_As_bool(obj1));
13015 if (SWIG_arg_fail(2)) SWIG_fail;
13016 }
13017 }
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 (arg1)->SetMask(arg2);
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 Py_INCREF(Py_None); resultobj = Py_None;
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13033 PyObject *resultobj;
13034 wxImage *arg1 = (wxImage *) 0 ;
13035 bool result;
13036 PyObject * obj0 = 0 ;
13037 char *kwnames[] = {
13038 (char *) "self", NULL
13039 };
13040
13041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(1)) SWIG_fail;
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 result = (bool)(arg1)->HasMask();
13047
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 {
13052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13053 }
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj;
13062 wxImage *arg1 = (wxImage *) 0 ;
13063 double arg2 ;
13064 wxPoint *arg3 = 0 ;
13065 bool arg4 = (bool) true ;
13066 wxPoint *arg5 = (wxPoint *) NULL ;
13067 SwigValueWrapper<wxImage > result;
13068 wxPoint temp3 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 PyObject * obj2 = 0 ;
13072 PyObject * obj3 = 0 ;
13073 PyObject * obj4 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 arg2 = (double)(SWIG_As_double(obj1));
13083 if (SWIG_arg_fail(2)) SWIG_fail;
13084 }
13085 {
13086 arg3 = &temp3;
13087 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13088 }
13089 if (obj3) {
13090 {
13091 arg4 = (bool)(SWIG_As_bool(obj3));
13092 if (SWIG_arg_fail(4)) SWIG_fail;
13093 }
13094 }
13095 if (obj4) {
13096 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13097 if (SWIG_arg_fail(5)) SWIG_fail;
13098 }
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13102
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 {
13107 wxImage * resultptr;
13108 resultptr = new wxImage((wxImage &)(result));
13109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13110 }
13111 return resultobj;
13112 fail:
13113 return NULL;
13114 }
13115
13116
13117 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj;
13119 wxImage *arg1 = (wxImage *) 0 ;
13120 bool arg2 = (bool) true ;
13121 SwigValueWrapper<wxImage > result;
13122 PyObject * obj0 = 0 ;
13123 PyObject * obj1 = 0 ;
13124 char *kwnames[] = {
13125 (char *) "self",(char *) "clockwise", NULL
13126 };
13127
13128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13130 if (SWIG_arg_fail(1)) SWIG_fail;
13131 if (obj1) {
13132 {
13133 arg2 = (bool)(SWIG_As_bool(obj1));
13134 if (SWIG_arg_fail(2)) SWIG_fail;
13135 }
13136 }
13137 {
13138 PyThreadState* __tstate = wxPyBeginAllowThreads();
13139 result = (arg1)->Rotate90(arg2);
13140
13141 wxPyEndAllowThreads(__tstate);
13142 if (PyErr_Occurred()) SWIG_fail;
13143 }
13144 {
13145 wxImage * resultptr;
13146 resultptr = new wxImage((wxImage &)(result));
13147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13148 }
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj;
13157 wxImage *arg1 = (wxImage *) 0 ;
13158 bool arg2 = (bool) true ;
13159 SwigValueWrapper<wxImage > result;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 char *kwnames[] = {
13163 (char *) "self",(char *) "horizontally", NULL
13164 };
13165
13166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13168 if (SWIG_arg_fail(1)) SWIG_fail;
13169 if (obj1) {
13170 {
13171 arg2 = (bool)(SWIG_As_bool(obj1));
13172 if (SWIG_arg_fail(2)) SWIG_fail;
13173 }
13174 }
13175 {
13176 PyThreadState* __tstate = wxPyBeginAllowThreads();
13177 result = (arg1)->Mirror(arg2);
13178
13179 wxPyEndAllowThreads(__tstate);
13180 if (PyErr_Occurred()) SWIG_fail;
13181 }
13182 {
13183 wxImage * resultptr;
13184 resultptr = new wxImage((wxImage &)(result));
13185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13186 }
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj;
13195 wxImage *arg1 = (wxImage *) 0 ;
13196 unsigned char arg2 ;
13197 unsigned char arg3 ;
13198 unsigned char arg4 ;
13199 unsigned char arg5 ;
13200 unsigned char arg6 ;
13201 unsigned char arg7 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 PyObject * obj3 = 0 ;
13206 PyObject * obj4 = 0 ;
13207 PyObject * obj5 = 0 ;
13208 PyObject * obj6 = 0 ;
13209 char *kwnames[] = {
13210 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13211 };
13212
13213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13215 if (SWIG_arg_fail(1)) SWIG_fail;
13216 {
13217 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13218 if (SWIG_arg_fail(2)) SWIG_fail;
13219 }
13220 {
13221 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13222 if (SWIG_arg_fail(3)) SWIG_fail;
13223 }
13224 {
13225 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13226 if (SWIG_arg_fail(4)) SWIG_fail;
13227 }
13228 {
13229 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13230 if (SWIG_arg_fail(5)) SWIG_fail;
13231 }
13232 {
13233 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13234 if (SWIG_arg_fail(6)) SWIG_fail;
13235 }
13236 {
13237 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13238 if (SWIG_arg_fail(7)) SWIG_fail;
13239 }
13240 {
13241 PyThreadState* __tstate = wxPyBeginAllowThreads();
13242 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13243
13244 wxPyEndAllowThreads(__tstate);
13245 if (PyErr_Occurred()) SWIG_fail;
13246 }
13247 Py_INCREF(Py_None); resultobj = Py_None;
13248 return resultobj;
13249 fail:
13250 return NULL;
13251 }
13252
13253
13254 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13255 PyObject *resultobj;
13256 wxImage *arg1 = (wxImage *) 0 ;
13257 unsigned char arg2 ;
13258 unsigned char arg3 ;
13259 unsigned char arg4 ;
13260 SwigValueWrapper<wxImage > result;
13261 PyObject * obj0 = 0 ;
13262 PyObject * obj1 = 0 ;
13263 PyObject * obj2 = 0 ;
13264 PyObject * obj3 = 0 ;
13265 char *kwnames[] = {
13266 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13267 };
13268
13269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13271 if (SWIG_arg_fail(1)) SWIG_fail;
13272 {
13273 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13274 if (SWIG_arg_fail(2)) SWIG_fail;
13275 }
13276 {
13277 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13278 if (SWIG_arg_fail(3)) SWIG_fail;
13279 }
13280 {
13281 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13282 if (SWIG_arg_fail(4)) SWIG_fail;
13283 }
13284 {
13285 PyThreadState* __tstate = wxPyBeginAllowThreads();
13286 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13287
13288 wxPyEndAllowThreads(__tstate);
13289 if (PyErr_Occurred()) SWIG_fail;
13290 }
13291 {
13292 wxImage * resultptr;
13293 resultptr = new wxImage((wxImage &)(result));
13294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13295 }
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13303 PyObject *resultobj;
13304 wxImage *arg1 = (wxImage *) 0 ;
13305 wxString *arg2 = 0 ;
13306 wxString *arg3 = 0 ;
13307 bool temp2 = false ;
13308 bool temp3 = false ;
13309 PyObject * obj0 = 0 ;
13310 PyObject * obj1 = 0 ;
13311 PyObject * obj2 = 0 ;
13312 char *kwnames[] = {
13313 (char *) "self",(char *) "name",(char *) "value", NULL
13314 };
13315
13316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13318 if (SWIG_arg_fail(1)) SWIG_fail;
13319 {
13320 arg2 = wxString_in_helper(obj1);
13321 if (arg2 == NULL) SWIG_fail;
13322 temp2 = true;
13323 }
13324 {
13325 arg3 = wxString_in_helper(obj2);
13326 if (arg3 == NULL) SWIG_fail;
13327 temp3 = true;
13328 }
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13332
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 Py_INCREF(Py_None); resultobj = Py_None;
13337 {
13338 if (temp2)
13339 delete arg2;
13340 }
13341 {
13342 if (temp3)
13343 delete arg3;
13344 }
13345 return resultobj;
13346 fail:
13347 {
13348 if (temp2)
13349 delete arg2;
13350 }
13351 {
13352 if (temp3)
13353 delete arg3;
13354 }
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj;
13361 wxImage *arg1 = (wxImage *) 0 ;
13362 wxString *arg2 = 0 ;
13363 int arg3 ;
13364 bool temp2 = false ;
13365 PyObject * obj0 = 0 ;
13366 PyObject * obj1 = 0 ;
13367 PyObject * obj2 = 0 ;
13368 char *kwnames[] = {
13369 (char *) "self",(char *) "name",(char *) "value", NULL
13370 };
13371
13372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13374 if (SWIG_arg_fail(1)) SWIG_fail;
13375 {
13376 arg2 = wxString_in_helper(obj1);
13377 if (arg2 == NULL) SWIG_fail;
13378 temp2 = true;
13379 }
13380 {
13381 arg3 = (int)(SWIG_As_int(obj2));
13382 if (SWIG_arg_fail(3)) SWIG_fail;
13383 }
13384 {
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 (arg1)->SetOption((wxString const &)*arg2,arg3);
13387
13388 wxPyEndAllowThreads(__tstate);
13389 if (PyErr_Occurred()) SWIG_fail;
13390 }
13391 Py_INCREF(Py_None); resultobj = Py_None;
13392 {
13393 if (temp2)
13394 delete arg2;
13395 }
13396 return resultobj;
13397 fail:
13398 {
13399 if (temp2)
13400 delete arg2;
13401 }
13402 return NULL;
13403 }
13404
13405
13406 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj;
13408 wxImage *arg1 = (wxImage *) 0 ;
13409 wxString *arg2 = 0 ;
13410 wxString result;
13411 bool temp2 = false ;
13412 PyObject * obj0 = 0 ;
13413 PyObject * obj1 = 0 ;
13414 char *kwnames[] = {
13415 (char *) "self",(char *) "name", NULL
13416 };
13417
13418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13420 if (SWIG_arg_fail(1)) SWIG_fail;
13421 {
13422 arg2 = wxString_in_helper(obj1);
13423 if (arg2 == NULL) SWIG_fail;
13424 temp2 = true;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13429
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 {
13434 #if wxUSE_UNICODE
13435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13436 #else
13437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13438 #endif
13439 }
13440 {
13441 if (temp2)
13442 delete arg2;
13443 }
13444 return resultobj;
13445 fail:
13446 {
13447 if (temp2)
13448 delete arg2;
13449 }
13450 return NULL;
13451 }
13452
13453
13454 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13455 PyObject *resultobj;
13456 wxImage *arg1 = (wxImage *) 0 ;
13457 wxString *arg2 = 0 ;
13458 int result;
13459 bool temp2 = false ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 char *kwnames[] = {
13463 (char *) "self",(char *) "name", NULL
13464 };
13465
13466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13468 if (SWIG_arg_fail(1)) SWIG_fail;
13469 {
13470 arg2 = wxString_in_helper(obj1);
13471 if (arg2 == NULL) SWIG_fail;
13472 temp2 = true;
13473 }
13474 {
13475 PyThreadState* __tstate = wxPyBeginAllowThreads();
13476 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13477
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 {
13482 resultobj = SWIG_From_int((int)(result));
13483 }
13484 {
13485 if (temp2)
13486 delete arg2;
13487 }
13488 return resultobj;
13489 fail:
13490 {
13491 if (temp2)
13492 delete arg2;
13493 }
13494 return NULL;
13495 }
13496
13497
13498 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13499 PyObject *resultobj;
13500 wxImage *arg1 = (wxImage *) 0 ;
13501 wxString *arg2 = 0 ;
13502 bool result;
13503 bool temp2 = false ;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 char *kwnames[] = {
13507 (char *) "self",(char *) "name", NULL
13508 };
13509
13510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13512 if (SWIG_arg_fail(1)) SWIG_fail;
13513 {
13514 arg2 = wxString_in_helper(obj1);
13515 if (arg2 == NULL) SWIG_fail;
13516 temp2 = true;
13517 }
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13521
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 {
13526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13527 }
13528 {
13529 if (temp2)
13530 delete arg2;
13531 }
13532 return resultobj;
13533 fail:
13534 {
13535 if (temp2)
13536 delete arg2;
13537 }
13538 return NULL;
13539 }
13540
13541
13542 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj;
13544 wxImage *arg1 = (wxImage *) 0 ;
13545 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13546 unsigned long result;
13547 PyObject * obj0 = 0 ;
13548 PyObject * obj1 = 0 ;
13549 char *kwnames[] = {
13550 (char *) "self",(char *) "stopafter", NULL
13551 };
13552
13553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13555 if (SWIG_arg_fail(1)) SWIG_fail;
13556 if (obj1) {
13557 {
13558 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13559 if (SWIG_arg_fail(2)) SWIG_fail;
13560 }
13561 }
13562 {
13563 PyThreadState* __tstate = wxPyBeginAllowThreads();
13564 result = (unsigned long)(arg1)->CountColours(arg2);
13565
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 {
13570 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13571 }
13572 return resultobj;
13573 fail:
13574 return NULL;
13575 }
13576
13577
13578 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13579 PyObject *resultobj;
13580 wxImage *arg1 = (wxImage *) 0 ;
13581 wxImageHistogram *arg2 = 0 ;
13582 unsigned long result;
13583 PyObject * obj0 = 0 ;
13584 PyObject * obj1 = 0 ;
13585 char *kwnames[] = {
13586 (char *) "self",(char *) "h", NULL
13587 };
13588
13589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13591 if (SWIG_arg_fail(1)) SWIG_fail;
13592 {
13593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13594 if (SWIG_arg_fail(2)) SWIG_fail;
13595 if (arg2 == NULL) {
13596 SWIG_null_ref("wxImageHistogram");
13597 }
13598 if (SWIG_arg_fail(2)) SWIG_fail;
13599 }
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13603
13604 wxPyEndAllowThreads(__tstate);
13605 if (PyErr_Occurred()) SWIG_fail;
13606 }
13607 {
13608 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13609 }
13610 return resultobj;
13611 fail:
13612 return NULL;
13613 }
13614
13615
13616 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13617 PyObject *resultobj;
13618 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13619 PyObject * obj0 = 0 ;
13620 char *kwnames[] = {
13621 (char *) "handler", NULL
13622 };
13623
13624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13626 if (SWIG_arg_fail(1)) SWIG_fail;
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 wxImage::AddHandler(arg1);
13630
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 Py_INCREF(Py_None); resultobj = Py_None;
13635 return resultobj;
13636 fail:
13637 return NULL;
13638 }
13639
13640
13641 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj;
13643 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13644 PyObject * obj0 = 0 ;
13645 char *kwnames[] = {
13646 (char *) "handler", NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13651 if (SWIG_arg_fail(1)) SWIG_fail;
13652 {
13653 PyThreadState* __tstate = wxPyBeginAllowThreads();
13654 wxImage::InsertHandler(arg1);
13655
13656 wxPyEndAllowThreads(__tstate);
13657 if (PyErr_Occurred()) SWIG_fail;
13658 }
13659 Py_INCREF(Py_None); resultobj = Py_None;
13660 return resultobj;
13661 fail:
13662 return NULL;
13663 }
13664
13665
13666 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj;
13668 wxString *arg1 = 0 ;
13669 bool result;
13670 bool temp1 = false ;
13671 PyObject * obj0 = 0 ;
13672 char *kwnames[] = {
13673 (char *) "name", NULL
13674 };
13675
13676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13677 {
13678 arg1 = wxString_in_helper(obj0);
13679 if (arg1 == NULL) SWIG_fail;
13680 temp1 = true;
13681 }
13682 {
13683 PyThreadState* __tstate = wxPyBeginAllowThreads();
13684 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13685
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 {
13690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13691 }
13692 {
13693 if (temp1)
13694 delete arg1;
13695 }
13696 return resultobj;
13697 fail:
13698 {
13699 if (temp1)
13700 delete arg1;
13701 }
13702 return NULL;
13703 }
13704
13705
13706 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13707 PyObject *resultobj;
13708 wxString result;
13709 char *kwnames[] = {
13710 NULL
13711 };
13712
13713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 result = wxImage::GetImageExtWildcard();
13717
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 {
13722 #if wxUSE_UNICODE
13723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13724 #else
13725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13726 #endif
13727 }
13728 return resultobj;
13729 fail:
13730 return NULL;
13731 }
13732
13733
13734 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13735 PyObject *resultobj;
13736 wxImage *arg1 = (wxImage *) 0 ;
13737 int arg2 = (int) -1 ;
13738 wxBitmap result;
13739 PyObject * obj0 = 0 ;
13740 PyObject * obj1 = 0 ;
13741 char *kwnames[] = {
13742 (char *) "self",(char *) "depth", NULL
13743 };
13744
13745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13747 if (SWIG_arg_fail(1)) SWIG_fail;
13748 if (obj1) {
13749 {
13750 arg2 = (int)(SWIG_As_int(obj1));
13751 if (SWIG_arg_fail(2)) SWIG_fail;
13752 }
13753 }
13754 {
13755 if (!wxPyCheckForApp()) SWIG_fail;
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 result = wxImage_ConvertToBitmap(arg1,arg2);
13758
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 {
13763 wxBitmap * resultptr;
13764 resultptr = new wxBitmap((wxBitmap &)(result));
13765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13766 }
13767 return resultobj;
13768 fail:
13769 return NULL;
13770 }
13771
13772
13773 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj;
13775 wxImage *arg1 = (wxImage *) 0 ;
13776 unsigned char arg2 ;
13777 unsigned char arg3 ;
13778 unsigned char arg4 ;
13779 wxBitmap result;
13780 PyObject * obj0 = 0 ;
13781 PyObject * obj1 = 0 ;
13782 PyObject * obj2 = 0 ;
13783 PyObject * obj3 = 0 ;
13784 char *kwnames[] = {
13785 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13786 };
13787
13788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13790 if (SWIG_arg_fail(1)) SWIG_fail;
13791 {
13792 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13793 if (SWIG_arg_fail(2)) SWIG_fail;
13794 }
13795 {
13796 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13797 if (SWIG_arg_fail(3)) SWIG_fail;
13798 }
13799 {
13800 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13801 if (SWIG_arg_fail(4)) SWIG_fail;
13802 }
13803 {
13804 if (!wxPyCheckForApp()) SWIG_fail;
13805 PyThreadState* __tstate = wxPyBeginAllowThreads();
13806 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13807
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 {
13812 wxBitmap * resultptr;
13813 resultptr = new wxBitmap((wxBitmap &)(result));
13814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13815 }
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13823 PyObject *obj;
13824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13825 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13826 Py_INCREF(obj);
13827 return Py_BuildValue((char *)"");
13828 }
13829 static int _wrap_NullImage_set(PyObject *) {
13830 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13831 return 1;
13832 }
13833
13834
13835 static PyObject *_wrap_NullImage_get(void) {
13836 PyObject *pyobj;
13837
13838 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13839 return pyobj;
13840 }
13841
13842
13843 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13844 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13845 return 1;
13846 }
13847
13848
13849 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13850 PyObject *pyobj;
13851
13852 {
13853 #if wxUSE_UNICODE
13854 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13855 #else
13856 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13857 #endif
13858 }
13859 return pyobj;
13860 }
13861
13862
13863 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13864 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13865 return 1;
13866 }
13867
13868
13869 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13870 PyObject *pyobj;
13871
13872 {
13873 #if wxUSE_UNICODE
13874 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13875 #else
13876 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13877 #endif
13878 }
13879 return pyobj;
13880 }
13881
13882
13883 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13884 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13885 return 1;
13886 }
13887
13888
13889 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13890 PyObject *pyobj;
13891
13892 {
13893 #if wxUSE_UNICODE
13894 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13895 #else
13896 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13897 #endif
13898 }
13899 return pyobj;
13900 }
13901
13902
13903 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13904 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13905 return 1;
13906 }
13907
13908
13909 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13910 PyObject *pyobj;
13911
13912 {
13913 #if wxUSE_UNICODE
13914 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13915 #else
13916 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13917 #endif
13918 }
13919 return pyobj;
13920 }
13921
13922
13923 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13924 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13925 return 1;
13926 }
13927
13928
13929 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13930 PyObject *pyobj;
13931
13932 {
13933 #if wxUSE_UNICODE
13934 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13935 #else
13936 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13937 #endif
13938 }
13939 return pyobj;
13940 }
13941
13942
13943 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13944 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13945 return 1;
13946 }
13947
13948
13949 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13950 PyObject *pyobj;
13951
13952 {
13953 #if wxUSE_UNICODE
13954 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13955 #else
13956 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13957 #endif
13958 }
13959 return pyobj;
13960 }
13961
13962
13963 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13964 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13965 return 1;
13966 }
13967
13968
13969 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13970 PyObject *pyobj;
13971
13972 {
13973 #if wxUSE_UNICODE
13974 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13975 #else
13976 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13977 #endif
13978 }
13979 return pyobj;
13980 }
13981
13982
13983 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13984 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13985 return 1;
13986 }
13987
13988
13989 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13990 PyObject *pyobj;
13991
13992 {
13993 #if wxUSE_UNICODE
13994 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13995 #else
13996 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13997 #endif
13998 }
13999 return pyobj;
14000 }
14001
14002
14003 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14004 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14005 return 1;
14006 }
14007
14008
14009 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14010 PyObject *pyobj;
14011
14012 {
14013 #if wxUSE_UNICODE
14014 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14015 #else
14016 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14017 #endif
14018 }
14019 return pyobj;
14020 }
14021
14022
14023 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14024 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14025 return 1;
14026 }
14027
14028
14029 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14030 PyObject *pyobj;
14031
14032 {
14033 #if wxUSE_UNICODE
14034 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14035 #else
14036 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14037 #endif
14038 }
14039 return pyobj;
14040 }
14041
14042
14043 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14044 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14045 return 1;
14046 }
14047
14048
14049 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14050 PyObject *pyobj;
14051
14052 {
14053 #if wxUSE_UNICODE
14054 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14055 #else
14056 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14057 #endif
14058 }
14059 return pyobj;
14060 }
14061
14062
14063 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14064 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14065 return 1;
14066 }
14067
14068
14069 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14070 PyObject *pyobj;
14071
14072 {
14073 #if wxUSE_UNICODE
14074 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14075 #else
14076 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14077 #endif
14078 }
14079 return pyobj;
14080 }
14081
14082
14083 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14084 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14085 return 1;
14086 }
14087
14088
14089 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14090 PyObject *pyobj;
14091
14092 {
14093 #if wxUSE_UNICODE
14094 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14095 #else
14096 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14097 #endif
14098 }
14099 return pyobj;
14100 }
14101
14102
14103 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14104 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14105 return 1;
14106 }
14107
14108
14109 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14110 PyObject *pyobj;
14111
14112 {
14113 #if wxUSE_UNICODE
14114 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14115 #else
14116 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14117 #endif
14118 }
14119 return pyobj;
14120 }
14121
14122
14123 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14124 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14125 return 1;
14126 }
14127
14128
14129 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14130 PyObject *pyobj;
14131
14132 {
14133 #if wxUSE_UNICODE
14134 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14135 #else
14136 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14137 #endif
14138 }
14139 return pyobj;
14140 }
14141
14142
14143 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj;
14145 wxBMPHandler *result;
14146 char *kwnames[] = {
14147 NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 result = (wxBMPHandler *)new wxBMPHandler();
14154
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14159 return resultobj;
14160 fail:
14161 return NULL;
14162 }
14163
14164
14165 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14166 PyObject *obj;
14167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14168 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14169 Py_INCREF(obj);
14170 return Py_BuildValue((char *)"");
14171 }
14172 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14173 PyObject *resultobj;
14174 wxICOHandler *result;
14175 char *kwnames[] = {
14176 NULL
14177 };
14178
14179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 result = (wxICOHandler *)new wxICOHandler();
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14195 PyObject *obj;
14196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14197 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14198 Py_INCREF(obj);
14199 return Py_BuildValue((char *)"");
14200 }
14201 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14202 PyObject *resultobj;
14203 wxCURHandler *result;
14204 char *kwnames[] = {
14205 NULL
14206 };
14207
14208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (wxCURHandler *)new wxCURHandler();
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14224 PyObject *obj;
14225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14226 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14227 Py_INCREF(obj);
14228 return Py_BuildValue((char *)"");
14229 }
14230 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14231 PyObject *resultobj;
14232 wxANIHandler *result;
14233 char *kwnames[] = {
14234 NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 result = (wxANIHandler *)new wxANIHandler();
14241
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14246 return resultobj;
14247 fail:
14248 return NULL;
14249 }
14250
14251
14252 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14253 PyObject *obj;
14254 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14255 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14256 Py_INCREF(obj);
14257 return Py_BuildValue((char *)"");
14258 }
14259 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj;
14261 wxPNGHandler *result;
14262 char *kwnames[] = {
14263 NULL
14264 };
14265
14266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 result = (wxPNGHandler *)new wxPNGHandler();
14270
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14282 PyObject *obj;
14283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14284 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14285 Py_INCREF(obj);
14286 return Py_BuildValue((char *)"");
14287 }
14288 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14289 PyObject *resultobj;
14290 wxGIFHandler *result;
14291 char *kwnames[] = {
14292 NULL
14293 };
14294
14295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 result = (wxGIFHandler *)new wxGIFHandler();
14299
14300 wxPyEndAllowThreads(__tstate);
14301 if (PyErr_Occurred()) SWIG_fail;
14302 }
14303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14311 PyObject *obj;
14312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14313 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14314 Py_INCREF(obj);
14315 return Py_BuildValue((char *)"");
14316 }
14317 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14318 PyObject *resultobj;
14319 wxPCXHandler *result;
14320 char *kwnames[] = {
14321 NULL
14322 };
14323
14324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (wxPCXHandler *)new wxPCXHandler();
14328
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14333 return resultobj;
14334 fail:
14335 return NULL;
14336 }
14337
14338
14339 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14340 PyObject *obj;
14341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14342 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14343 Py_INCREF(obj);
14344 return Py_BuildValue((char *)"");
14345 }
14346 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj;
14348 wxJPEGHandler *result;
14349 char *kwnames[] = {
14350 NULL
14351 };
14352
14353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14354 {
14355 PyThreadState* __tstate = wxPyBeginAllowThreads();
14356 result = (wxJPEGHandler *)new wxJPEGHandler();
14357
14358 wxPyEndAllowThreads(__tstate);
14359 if (PyErr_Occurred()) SWIG_fail;
14360 }
14361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14362 return resultobj;
14363 fail:
14364 return NULL;
14365 }
14366
14367
14368 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14369 PyObject *obj;
14370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14371 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14372 Py_INCREF(obj);
14373 return Py_BuildValue((char *)"");
14374 }
14375 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14376 PyObject *resultobj;
14377 wxPNMHandler *result;
14378 char *kwnames[] = {
14379 NULL
14380 };
14381
14382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 result = (wxPNMHandler *)new wxPNMHandler();
14386
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14398 PyObject *obj;
14399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14400 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14401 Py_INCREF(obj);
14402 return Py_BuildValue((char *)"");
14403 }
14404 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxXPMHandler *result;
14407 char *kwnames[] = {
14408 NULL
14409 };
14410
14411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (wxXPMHandler *)new wxXPMHandler();
14415
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14420 return resultobj;
14421 fail:
14422 return NULL;
14423 }
14424
14425
14426 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14427 PyObject *obj;
14428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14429 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14430 Py_INCREF(obj);
14431 return Py_BuildValue((char *)"");
14432 }
14433 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj;
14435 wxTIFFHandler *result;
14436 char *kwnames[] = {
14437 NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (wxTIFFHandler *)new wxTIFFHandler();
14444
14445 wxPyEndAllowThreads(__tstate);
14446 if (PyErr_Occurred()) SWIG_fail;
14447 }
14448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14449 return resultobj;
14450 fail:
14451 return NULL;
14452 }
14453
14454
14455 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14456 PyObject *obj;
14457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14458 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14459 Py_INCREF(obj);
14460 return Py_BuildValue((char *)"");
14461 }
14462 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14463 PyObject *resultobj;
14464 wxImage *arg1 = 0 ;
14465 wxImage *arg2 = 0 ;
14466 int arg3 = (int) 236 ;
14467 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14468 bool result;
14469 PyObject * obj0 = 0 ;
14470 PyObject * obj1 = 0 ;
14471 PyObject * obj2 = 0 ;
14472 PyObject * obj3 = 0 ;
14473 char *kwnames[] = {
14474 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14475 };
14476
14477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14478 {
14479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14480 if (SWIG_arg_fail(1)) SWIG_fail;
14481 if (arg1 == NULL) {
14482 SWIG_null_ref("wxImage");
14483 }
14484 if (SWIG_arg_fail(1)) SWIG_fail;
14485 }
14486 {
14487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14488 if (SWIG_arg_fail(2)) SWIG_fail;
14489 if (arg2 == NULL) {
14490 SWIG_null_ref("wxImage");
14491 }
14492 if (SWIG_arg_fail(2)) SWIG_fail;
14493 }
14494 if (obj2) {
14495 {
14496 arg3 = (int)(SWIG_As_int(obj2));
14497 if (SWIG_arg_fail(3)) SWIG_fail;
14498 }
14499 }
14500 if (obj3) {
14501 {
14502 arg4 = (int)(SWIG_As_int(obj3));
14503 if (SWIG_arg_fail(4)) SWIG_fail;
14504 }
14505 }
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14509
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 {
14514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14515 }
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14523 PyObject *obj;
14524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14525 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14526 Py_INCREF(obj);
14527 return Py_BuildValue((char *)"");
14528 }
14529 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14530 PyObject *resultobj;
14531 wxEvtHandler *result;
14532 char *kwnames[] = {
14533 NULL
14534 };
14535
14536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (wxEvtHandler *)new wxEvtHandler();
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14545 return resultobj;
14546 fail:
14547 return NULL;
14548 }
14549
14550
14551 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14552 PyObject *resultobj;
14553 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14554 wxEvtHandler *result;
14555 PyObject * obj0 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14566
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 {
14571 resultobj = wxPyMake_wxObject(result, 0);
14572 }
14573 return resultobj;
14574 fail:
14575 return NULL;
14576 }
14577
14578
14579 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14580 PyObject *resultobj;
14581 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14582 wxEvtHandler *result;
14583 PyObject * obj0 = 0 ;
14584 char *kwnames[] = {
14585 (char *) "self", NULL
14586 };
14587
14588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14590 if (SWIG_arg_fail(1)) SWIG_fail;
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14594
14595 wxPyEndAllowThreads(__tstate);
14596 if (PyErr_Occurred()) SWIG_fail;
14597 }
14598 {
14599 resultobj = wxPyMake_wxObject(result, 0);
14600 }
14601 return resultobj;
14602 fail:
14603 return NULL;
14604 }
14605
14606
14607 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj;
14609 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14610 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14611 PyObject * obj0 = 0 ;
14612 PyObject * obj1 = 0 ;
14613 char *kwnames[] = {
14614 (char *) "self",(char *) "handler", NULL
14615 };
14616
14617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14619 if (SWIG_arg_fail(1)) SWIG_fail;
14620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(2)) SWIG_fail;
14622 {
14623 PyThreadState* __tstate = wxPyBeginAllowThreads();
14624 (arg1)->SetNextHandler(arg2);
14625
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 Py_INCREF(Py_None); resultobj = Py_None;
14630 return resultobj;
14631 fail:
14632 return NULL;
14633 }
14634
14635
14636 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14637 PyObject *resultobj;
14638 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14639 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14640 PyObject * obj0 = 0 ;
14641 PyObject * obj1 = 0 ;
14642 char *kwnames[] = {
14643 (char *) "self",(char *) "handler", NULL
14644 };
14645
14646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14648 if (SWIG_arg_fail(1)) SWIG_fail;
14649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14650 if (SWIG_arg_fail(2)) SWIG_fail;
14651 {
14652 PyThreadState* __tstate = wxPyBeginAllowThreads();
14653 (arg1)->SetPreviousHandler(arg2);
14654
14655 wxPyEndAllowThreads(__tstate);
14656 if (PyErr_Occurred()) SWIG_fail;
14657 }
14658 Py_INCREF(Py_None); resultobj = Py_None;
14659 return resultobj;
14660 fail:
14661 return NULL;
14662 }
14663
14664
14665 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14666 PyObject *resultobj;
14667 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14668 bool result;
14669 PyObject * obj0 = 0 ;
14670 char *kwnames[] = {
14671 (char *) "self", NULL
14672 };
14673
14674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14676 if (SWIG_arg_fail(1)) SWIG_fail;
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (bool)(arg1)->GetEvtHandlerEnabled();
14680
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 {
14685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14686 }
14687 return resultobj;
14688 fail:
14689 return NULL;
14690 }
14691
14692
14693 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14694 PyObject *resultobj;
14695 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14696 bool arg2 ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char *kwnames[] = {
14700 (char *) "self",(char *) "enabled", NULL
14701 };
14702
14703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14705 if (SWIG_arg_fail(1)) SWIG_fail;
14706 {
14707 arg2 = (bool)(SWIG_As_bool(obj1));
14708 if (SWIG_arg_fail(2)) SWIG_fail;
14709 }
14710 {
14711 PyThreadState* __tstate = wxPyBeginAllowThreads();
14712 (arg1)->SetEvtHandlerEnabled(arg2);
14713
14714 wxPyEndAllowThreads(__tstate);
14715 if (PyErr_Occurred()) SWIG_fail;
14716 }
14717 Py_INCREF(Py_None); resultobj = Py_None;
14718 return resultobj;
14719 fail:
14720 return NULL;
14721 }
14722
14723
14724 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14725 PyObject *resultobj;
14726 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14727 wxEvent *arg2 = 0 ;
14728 bool result;
14729 PyObject * obj0 = 0 ;
14730 PyObject * obj1 = 0 ;
14731 char *kwnames[] = {
14732 (char *) "self",(char *) "event", NULL
14733 };
14734
14735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14737 if (SWIG_arg_fail(1)) SWIG_fail;
14738 {
14739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(2)) SWIG_fail;
14741 if (arg2 == NULL) {
14742 SWIG_null_ref("wxEvent");
14743 }
14744 if (SWIG_arg_fail(2)) SWIG_fail;
14745 }
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = (bool)(arg1)->ProcessEvent(*arg2);
14749
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 {
14754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14755 }
14756 return resultobj;
14757 fail:
14758 return NULL;
14759 }
14760
14761
14762 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14763 PyObject *resultobj;
14764 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14765 wxEvent *arg2 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 char *kwnames[] = {
14769 (char *) "self",(char *) "event", NULL
14770 };
14771
14772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14774 if (SWIG_arg_fail(1)) SWIG_fail;
14775 {
14776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14777 if (SWIG_arg_fail(2)) SWIG_fail;
14778 if (arg2 == NULL) {
14779 SWIG_null_ref("wxEvent");
14780 }
14781 if (SWIG_arg_fail(2)) SWIG_fail;
14782 }
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 (arg1)->AddPendingEvent(*arg2);
14786
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 Py_INCREF(Py_None); resultobj = Py_None;
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj;
14799 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14800 PyObject * obj0 = 0 ;
14801 char *kwnames[] = {
14802 (char *) "self", NULL
14803 };
14804
14805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14807 if (SWIG_arg_fail(1)) SWIG_fail;
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 (arg1)->ProcessPendingEvents();
14811
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 Py_INCREF(Py_None); resultobj = Py_None;
14816 return resultobj;
14817 fail:
14818 return NULL;
14819 }
14820
14821
14822 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj;
14824 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14825 int arg2 ;
14826 int arg3 ;
14827 int arg4 ;
14828 PyObject *arg5 = (PyObject *) 0 ;
14829 PyObject * obj0 = 0 ;
14830 PyObject * obj1 = 0 ;
14831 PyObject * obj2 = 0 ;
14832 PyObject * obj3 = 0 ;
14833 PyObject * obj4 = 0 ;
14834 char *kwnames[] = {
14835 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14836 };
14837
14838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 {
14842 arg2 = (int)(SWIG_As_int(obj1));
14843 if (SWIG_arg_fail(2)) SWIG_fail;
14844 }
14845 {
14846 arg3 = (int)(SWIG_As_int(obj2));
14847 if (SWIG_arg_fail(3)) SWIG_fail;
14848 }
14849 {
14850 arg4 = (int)(SWIG_As_int(obj3));
14851 if (SWIG_arg_fail(4)) SWIG_fail;
14852 }
14853 arg5 = obj4;
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14857
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 Py_INCREF(Py_None); resultobj = Py_None;
14862 return resultobj;
14863 fail:
14864 return NULL;
14865 }
14866
14867
14868 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj;
14870 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14871 int arg2 ;
14872 int arg3 = (int) -1 ;
14873 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14874 bool result;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 PyObject * obj3 = 0 ;
14879 char *kwnames[] = {
14880 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14881 };
14882
14883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14885 if (SWIG_arg_fail(1)) SWIG_fail;
14886 {
14887 arg2 = (int)(SWIG_As_int(obj1));
14888 if (SWIG_arg_fail(2)) SWIG_fail;
14889 }
14890 if (obj2) {
14891 {
14892 arg3 = (int)(SWIG_As_int(obj2));
14893 if (SWIG_arg_fail(3)) SWIG_fail;
14894 }
14895 }
14896 if (obj3) {
14897 {
14898 arg4 = (wxEventType)(SWIG_As_int(obj3));
14899 if (SWIG_arg_fail(4)) SWIG_fail;
14900 }
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14905
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 {
14910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14911 }
14912 return resultobj;
14913 fail:
14914 return NULL;
14915 }
14916
14917
14918 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14919 PyObject *resultobj;
14920 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14921 PyObject *arg2 = (PyObject *) 0 ;
14922 bool arg3 = (bool) true ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 PyObject * obj2 = 0 ;
14926 char *kwnames[] = {
14927 (char *) "self",(char *) "_self",(char *) "incref", NULL
14928 };
14929
14930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14932 if (SWIG_arg_fail(1)) SWIG_fail;
14933 arg2 = obj1;
14934 if (obj2) {
14935 {
14936 arg3 = (bool)(SWIG_As_bool(obj2));
14937 if (SWIG_arg_fail(3)) SWIG_fail;
14938 }
14939 }
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 Py_INCREF(Py_None); resultobj = Py_None;
14948 return resultobj;
14949 fail:
14950 return NULL;
14951 }
14952
14953
14954 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14955 PyObject *obj;
14956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14957 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14958 Py_INCREF(obj);
14959 return Py_BuildValue((char *)"");
14960 }
14961 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxEventType result;
14964 char *kwnames[] = {
14965 NULL
14966 };
14967
14968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (wxEventType)wxNewEventType();
14972
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 {
14977 resultobj = SWIG_From_int((int)(result));
14978 }
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj;
14987 wxEvent *arg1 = (wxEvent *) 0 ;
14988 PyObject * obj0 = 0 ;
14989 char *kwnames[] = {
14990 (char *) "self", NULL
14991 };
14992
14993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14995 if (SWIG_arg_fail(1)) SWIG_fail;
14996 {
14997 PyThreadState* __tstate = wxPyBeginAllowThreads();
14998 delete arg1;
14999
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 Py_INCREF(Py_None); resultobj = Py_None;
15004 return resultobj;
15005 fail:
15006 return NULL;
15007 }
15008
15009
15010 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15011 PyObject *resultobj;
15012 wxEvent *arg1 = (wxEvent *) 0 ;
15013 wxEventType arg2 ;
15014 PyObject * obj0 = 0 ;
15015 PyObject * obj1 = 0 ;
15016 char *kwnames[] = {
15017 (char *) "self",(char *) "typ", NULL
15018 };
15019
15020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15022 if (SWIG_arg_fail(1)) SWIG_fail;
15023 {
15024 arg2 = (wxEventType)(SWIG_As_int(obj1));
15025 if (SWIG_arg_fail(2)) SWIG_fail;
15026 }
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 (arg1)->SetEventType(arg2);
15030
15031 wxPyEndAllowThreads(__tstate);
15032 if (PyErr_Occurred()) SWIG_fail;
15033 }
15034 Py_INCREF(Py_None); resultobj = Py_None;
15035 return resultobj;
15036 fail:
15037 return NULL;
15038 }
15039
15040
15041 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15042 PyObject *resultobj;
15043 wxEvent *arg1 = (wxEvent *) 0 ;
15044 wxEventType result;
15045 PyObject * obj0 = 0 ;
15046 char *kwnames[] = {
15047 (char *) "self", NULL
15048 };
15049
15050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15052 if (SWIG_arg_fail(1)) SWIG_fail;
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15056
15057 wxPyEndAllowThreads(__tstate);
15058 if (PyErr_Occurred()) SWIG_fail;
15059 }
15060 {
15061 resultobj = SWIG_From_int((int)(result));
15062 }
15063 return resultobj;
15064 fail:
15065 return NULL;
15066 }
15067
15068
15069 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15070 PyObject *resultobj;
15071 wxEvent *arg1 = (wxEvent *) 0 ;
15072 wxObject *result;
15073 PyObject * obj0 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15084
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 {
15089 resultobj = wxPyMake_wxObject(result, 0);
15090 }
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15098 PyObject *resultobj;
15099 wxEvent *arg1 = (wxEvent *) 0 ;
15100 wxObject *arg2 = (wxObject *) 0 ;
15101 PyObject * obj0 = 0 ;
15102 PyObject * obj1 = 0 ;
15103 char *kwnames[] = {
15104 (char *) "self",(char *) "obj", NULL
15105 };
15106
15107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15109 if (SWIG_arg_fail(1)) SWIG_fail;
15110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15111 if (SWIG_arg_fail(2)) SWIG_fail;
15112 {
15113 PyThreadState* __tstate = wxPyBeginAllowThreads();
15114 (arg1)->SetEventObject(arg2);
15115
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 Py_INCREF(Py_None); resultobj = Py_None;
15120 return resultobj;
15121 fail:
15122 return NULL;
15123 }
15124
15125
15126 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15127 PyObject *resultobj;
15128 wxEvent *arg1 = (wxEvent *) 0 ;
15129 long result;
15130 PyObject * obj0 = 0 ;
15131 char *kwnames[] = {
15132 (char *) "self", NULL
15133 };
15134
15135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15137 if (SWIG_arg_fail(1)) SWIG_fail;
15138 {
15139 PyThreadState* __tstate = wxPyBeginAllowThreads();
15140 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15141
15142 wxPyEndAllowThreads(__tstate);
15143 if (PyErr_Occurred()) SWIG_fail;
15144 }
15145 {
15146 resultobj = SWIG_From_long((long)(result));
15147 }
15148 return resultobj;
15149 fail:
15150 return NULL;
15151 }
15152
15153
15154 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15155 PyObject *resultobj;
15156 wxEvent *arg1 = (wxEvent *) 0 ;
15157 long arg2 = (long) 0 ;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 char *kwnames[] = {
15161 (char *) "self",(char *) "ts", NULL
15162 };
15163
15164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15166 if (SWIG_arg_fail(1)) SWIG_fail;
15167 if (obj1) {
15168 {
15169 arg2 = (long)(SWIG_As_long(obj1));
15170 if (SWIG_arg_fail(2)) SWIG_fail;
15171 }
15172 }
15173 {
15174 PyThreadState* __tstate = wxPyBeginAllowThreads();
15175 (arg1)->SetTimestamp(arg2);
15176
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 Py_INCREF(Py_None); resultobj = Py_None;
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15188 PyObject *resultobj;
15189 wxEvent *arg1 = (wxEvent *) 0 ;
15190 int result;
15191 PyObject * obj0 = 0 ;
15192 char *kwnames[] = {
15193 (char *) "self", NULL
15194 };
15195
15196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15198 if (SWIG_arg_fail(1)) SWIG_fail;
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (int)((wxEvent const *)arg1)->GetId();
15202
15203 wxPyEndAllowThreads(__tstate);
15204 if (PyErr_Occurred()) SWIG_fail;
15205 }
15206 {
15207 resultobj = SWIG_From_int((int)(result));
15208 }
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15216 PyObject *resultobj;
15217 wxEvent *arg1 = (wxEvent *) 0 ;
15218 int arg2 ;
15219 PyObject * obj0 = 0 ;
15220 PyObject * obj1 = 0 ;
15221 char *kwnames[] = {
15222 (char *) "self",(char *) "Id", NULL
15223 };
15224
15225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15227 if (SWIG_arg_fail(1)) SWIG_fail;
15228 {
15229 arg2 = (int)(SWIG_As_int(obj1));
15230 if (SWIG_arg_fail(2)) SWIG_fail;
15231 }
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 (arg1)->SetId(arg2);
15235
15236 wxPyEndAllowThreads(__tstate);
15237 if (PyErr_Occurred()) SWIG_fail;
15238 }
15239 Py_INCREF(Py_None); resultobj = Py_None;
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj;
15248 wxEvent *arg1 = (wxEvent *) 0 ;
15249 bool result;
15250 PyObject * obj0 = 0 ;
15251 char *kwnames[] = {
15252 (char *) "self", NULL
15253 };
15254
15255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15257 if (SWIG_arg_fail(1)) SWIG_fail;
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15261
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 {
15266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15267 }
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxEvent *arg1 = (wxEvent *) 0 ;
15277 bool arg2 = (bool) true ;
15278 PyObject * obj0 = 0 ;
15279 PyObject * obj1 = 0 ;
15280 char *kwnames[] = {
15281 (char *) "self",(char *) "skip", NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 if (obj1) {
15288 {
15289 arg2 = (bool)(SWIG_As_bool(obj1));
15290 if (SWIG_arg_fail(2)) SWIG_fail;
15291 }
15292 }
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 (arg1)->Skip(arg2);
15296
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 Py_INCREF(Py_None); resultobj = Py_None;
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15308 PyObject *resultobj;
15309 wxEvent *arg1 = (wxEvent *) 0 ;
15310 bool result;
15311 PyObject * obj0 = 0 ;
15312 char *kwnames[] = {
15313 (char *) "self", NULL
15314 };
15315
15316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15318 if (SWIG_arg_fail(1)) SWIG_fail;
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15322
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 {
15327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15328 }
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15336 PyObject *resultobj;
15337 wxEvent *arg1 = (wxEvent *) 0 ;
15338 bool result;
15339 PyObject * obj0 = 0 ;
15340 char *kwnames[] = {
15341 (char *) "self", NULL
15342 };
15343
15344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15346 if (SWIG_arg_fail(1)) SWIG_fail;
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15350
15351 wxPyEndAllowThreads(__tstate);
15352 if (PyErr_Occurred()) SWIG_fail;
15353 }
15354 {
15355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15356 }
15357 return resultobj;
15358 fail:
15359 return NULL;
15360 }
15361
15362
15363 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15364 PyObject *resultobj;
15365 wxEvent *arg1 = (wxEvent *) 0 ;
15366 int result;
15367 PyObject * obj0 = 0 ;
15368 char *kwnames[] = {
15369 (char *) "self", NULL
15370 };
15371
15372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15374 if (SWIG_arg_fail(1)) SWIG_fail;
15375 {
15376 PyThreadState* __tstate = wxPyBeginAllowThreads();
15377 result = (int)(arg1)->StopPropagation();
15378
15379 wxPyEndAllowThreads(__tstate);
15380 if (PyErr_Occurred()) SWIG_fail;
15381 }
15382 {
15383 resultobj = SWIG_From_int((int)(result));
15384 }
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj;
15393 wxEvent *arg1 = (wxEvent *) 0 ;
15394 int arg2 ;
15395 PyObject * obj0 = 0 ;
15396 PyObject * obj1 = 0 ;
15397 char *kwnames[] = {
15398 (char *) "self",(char *) "propagationLevel", NULL
15399 };
15400
15401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15403 if (SWIG_arg_fail(1)) SWIG_fail;
15404 {
15405 arg2 = (int)(SWIG_As_int(obj1));
15406 if (SWIG_arg_fail(2)) SWIG_fail;
15407 }
15408 {
15409 PyThreadState* __tstate = wxPyBeginAllowThreads();
15410 (arg1)->ResumePropagation(arg2);
15411
15412 wxPyEndAllowThreads(__tstate);
15413 if (PyErr_Occurred()) SWIG_fail;
15414 }
15415 Py_INCREF(Py_None); resultobj = Py_None;
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15423 PyObject *resultobj;
15424 wxEvent *arg1 = (wxEvent *) 0 ;
15425 wxEvent *result;
15426 PyObject * obj0 = 0 ;
15427 char *kwnames[] = {
15428 (char *) "self", NULL
15429 };
15430
15431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15433 if (SWIG_arg_fail(1)) SWIG_fail;
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 result = (wxEvent *)(arg1)->Clone();
15437
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15449 PyObject *obj;
15450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15451 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15452 Py_INCREF(obj);
15453 return Py_BuildValue((char *)"");
15454 }
15455 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15456 PyObject *resultobj;
15457 wxEvent *arg1 = 0 ;
15458 wxPropagationDisabler *result;
15459 PyObject * obj0 = 0 ;
15460 char *kwnames[] = {
15461 (char *) "event", NULL
15462 };
15463
15464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15465 {
15466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15467 if (SWIG_arg_fail(1)) SWIG_fail;
15468 if (arg1 == NULL) {
15469 SWIG_null_ref("wxEvent");
15470 }
15471 if (SWIG_arg_fail(1)) SWIG_fail;
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15476
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj;
15489 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15490 PyObject * obj0 = 0 ;
15491 char *kwnames[] = {
15492 (char *) "self", NULL
15493 };
15494
15495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15497 if (SWIG_arg_fail(1)) SWIG_fail;
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 delete arg1;
15501
15502 wxPyEndAllowThreads(__tstate);
15503 if (PyErr_Occurred()) SWIG_fail;
15504 }
15505 Py_INCREF(Py_None); resultobj = Py_None;
15506 return resultobj;
15507 fail:
15508 return NULL;
15509 }
15510
15511
15512 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15513 PyObject *obj;
15514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15515 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15516 Py_INCREF(obj);
15517 return Py_BuildValue((char *)"");
15518 }
15519 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15520 PyObject *resultobj;
15521 wxEvent *arg1 = 0 ;
15522 wxPropagateOnce *result;
15523 PyObject * obj0 = 0 ;
15524 char *kwnames[] = {
15525 (char *) "event", NULL
15526 };
15527
15528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15529 {
15530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15531 if (SWIG_arg_fail(1)) SWIG_fail;
15532 if (arg1 == NULL) {
15533 SWIG_null_ref("wxEvent");
15534 }
15535 if (SWIG_arg_fail(1)) SWIG_fail;
15536 }
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15540
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj;
15553 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15554 PyObject * obj0 = 0 ;
15555 char *kwnames[] = {
15556 (char *) "self", NULL
15557 };
15558
15559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15561 if (SWIG_arg_fail(1)) SWIG_fail;
15562 {
15563 PyThreadState* __tstate = wxPyBeginAllowThreads();
15564 delete arg1;
15565
15566 wxPyEndAllowThreads(__tstate);
15567 if (PyErr_Occurred()) SWIG_fail;
15568 }
15569 Py_INCREF(Py_None); resultobj = Py_None;
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15577 PyObject *obj;
15578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15579 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15580 Py_INCREF(obj);
15581 return Py_BuildValue((char *)"");
15582 }
15583 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15584 PyObject *resultobj;
15585 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15586 int arg2 = (int) 0 ;
15587 wxCommandEvent *result;
15588 PyObject * obj0 = 0 ;
15589 PyObject * obj1 = 0 ;
15590 char *kwnames[] = {
15591 (char *) "commandType",(char *) "winid", NULL
15592 };
15593
15594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15595 if (obj0) {
15596 {
15597 arg1 = (wxEventType)(SWIG_As_int(obj0));
15598 if (SWIG_arg_fail(1)) SWIG_fail;
15599 }
15600 }
15601 if (obj1) {
15602 {
15603 arg2 = (int)(SWIG_As_int(obj1));
15604 if (SWIG_arg_fail(2)) SWIG_fail;
15605 }
15606 }
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15610
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj;
15623 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15624 int result;
15625 PyObject * obj0 = 0 ;
15626 char *kwnames[] = {
15627 (char *) "self", NULL
15628 };
15629
15630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15632 if (SWIG_arg_fail(1)) SWIG_fail;
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15636
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 {
15641 resultobj = SWIG_From_int((int)(result));
15642 }
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15650 PyObject *resultobj;
15651 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15652 wxString *arg2 = 0 ;
15653 bool temp2 = false ;
15654 PyObject * obj0 = 0 ;
15655 PyObject * obj1 = 0 ;
15656 char *kwnames[] = {
15657 (char *) "self",(char *) "s", NULL
15658 };
15659
15660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15662 if (SWIG_arg_fail(1)) SWIG_fail;
15663 {
15664 arg2 = wxString_in_helper(obj1);
15665 if (arg2 == NULL) SWIG_fail;
15666 temp2 = true;
15667 }
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 (arg1)->SetString((wxString const &)*arg2);
15671
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 Py_INCREF(Py_None); resultobj = Py_None;
15676 {
15677 if (temp2)
15678 delete arg2;
15679 }
15680 return resultobj;
15681 fail:
15682 {
15683 if (temp2)
15684 delete arg2;
15685 }
15686 return NULL;
15687 }
15688
15689
15690 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj;
15692 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15693 wxString result;
15694 PyObject * obj0 = 0 ;
15695 char *kwnames[] = {
15696 (char *) "self", NULL
15697 };
15698
15699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15701 if (SWIG_arg_fail(1)) SWIG_fail;
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 result = ((wxCommandEvent const *)arg1)->GetString();
15705
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 {
15710 #if wxUSE_UNICODE
15711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15712 #else
15713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15714 #endif
15715 }
15716 return resultobj;
15717 fail:
15718 return NULL;
15719 }
15720
15721
15722 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15723 PyObject *resultobj;
15724 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15725 bool result;
15726 PyObject * obj0 = 0 ;
15727 char *kwnames[] = {
15728 (char *) "self", NULL
15729 };
15730
15731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15733 if (SWIG_arg_fail(1)) SWIG_fail;
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15737
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 {
15742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15743 }
15744 return resultobj;
15745 fail:
15746 return NULL;
15747 }
15748
15749
15750 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15751 PyObject *resultobj;
15752 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15753 bool result;
15754 PyObject * obj0 = 0 ;
15755 char *kwnames[] = {
15756 (char *) "self", NULL
15757 };
15758
15759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15761 if (SWIG_arg_fail(1)) SWIG_fail;
15762 {
15763 PyThreadState* __tstate = wxPyBeginAllowThreads();
15764 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15765
15766 wxPyEndAllowThreads(__tstate);
15767 if (PyErr_Occurred()) SWIG_fail;
15768 }
15769 {
15770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15771 }
15772 return resultobj;
15773 fail:
15774 return NULL;
15775 }
15776
15777
15778 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15779 PyObject *resultobj;
15780 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15781 long arg2 ;
15782 PyObject * obj0 = 0 ;
15783 PyObject * obj1 = 0 ;
15784 char *kwnames[] = {
15785 (char *) "self",(char *) "extraLong", NULL
15786 };
15787
15788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15790 if (SWIG_arg_fail(1)) SWIG_fail;
15791 {
15792 arg2 = (long)(SWIG_As_long(obj1));
15793 if (SWIG_arg_fail(2)) SWIG_fail;
15794 }
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 (arg1)->SetExtraLong(arg2);
15798
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 Py_INCREF(Py_None); resultobj = Py_None;
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj;
15811 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15812 long result;
15813 PyObject * obj0 = 0 ;
15814 char *kwnames[] = {
15815 (char *) "self", NULL
15816 };
15817
15818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15820 if (SWIG_arg_fail(1)) SWIG_fail;
15821 {
15822 PyThreadState* __tstate = wxPyBeginAllowThreads();
15823 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15824
15825 wxPyEndAllowThreads(__tstate);
15826 if (PyErr_Occurred()) SWIG_fail;
15827 }
15828 {
15829 resultobj = SWIG_From_long((long)(result));
15830 }
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15838 PyObject *resultobj;
15839 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15840 int arg2 ;
15841 PyObject * obj0 = 0 ;
15842 PyObject * obj1 = 0 ;
15843 char *kwnames[] = {
15844 (char *) "self",(char *) "i", NULL
15845 };
15846
15847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15849 if (SWIG_arg_fail(1)) SWIG_fail;
15850 {
15851 arg2 = (int)(SWIG_As_int(obj1));
15852 if (SWIG_arg_fail(2)) SWIG_fail;
15853 }
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 (arg1)->SetInt(arg2);
15857
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 Py_INCREF(Py_None); resultobj = Py_None;
15862 return resultobj;
15863 fail:
15864 return NULL;
15865 }
15866
15867
15868 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15869 PyObject *resultobj;
15870 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15871 long result;
15872 PyObject * obj0 = 0 ;
15873 char *kwnames[] = {
15874 (char *) "self", NULL
15875 };
15876
15877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15879 if (SWIG_arg_fail(1)) SWIG_fail;
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15883
15884 wxPyEndAllowThreads(__tstate);
15885 if (PyErr_Occurred()) SWIG_fail;
15886 }
15887 {
15888 resultobj = SWIG_From_long((long)(result));
15889 }
15890 return resultobj;
15891 fail:
15892 return NULL;
15893 }
15894
15895
15896 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15897 PyObject *resultobj;
15898 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15899 wxEvent *result;
15900 PyObject * obj0 = 0 ;
15901 char *kwnames[] = {
15902 (char *) "self", NULL
15903 };
15904
15905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15907 if (SWIG_arg_fail(1)) SWIG_fail;
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15911
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15923 PyObject *obj;
15924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15925 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15926 Py_INCREF(obj);
15927 return Py_BuildValue((char *)"");
15928 }
15929 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj;
15931 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15932 int arg2 = (int) 0 ;
15933 wxNotifyEvent *result;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 char *kwnames[] = {
15937 (char *) "commandType",(char *) "winid", NULL
15938 };
15939
15940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15941 if (obj0) {
15942 {
15943 arg1 = (wxEventType)(SWIG_As_int(obj0));
15944 if (SWIG_arg_fail(1)) SWIG_fail;
15945 }
15946 }
15947 if (obj1) {
15948 {
15949 arg2 = (int)(SWIG_As_int(obj1));
15950 if (SWIG_arg_fail(2)) SWIG_fail;
15951 }
15952 }
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15956
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj;
15969 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15970 PyObject * obj0 = 0 ;
15971 char *kwnames[] = {
15972 (char *) "self", NULL
15973 };
15974
15975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15977 if (SWIG_arg_fail(1)) SWIG_fail;
15978 {
15979 PyThreadState* __tstate = wxPyBeginAllowThreads();
15980 (arg1)->Veto();
15981
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 Py_INCREF(Py_None); resultobj = Py_None;
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15993 PyObject *resultobj;
15994 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15995 PyObject * obj0 = 0 ;
15996 char *kwnames[] = {
15997 (char *) "self", NULL
15998 };
15999
16000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16002 if (SWIG_arg_fail(1)) SWIG_fail;
16003 {
16004 PyThreadState* __tstate = wxPyBeginAllowThreads();
16005 (arg1)->Allow();
16006
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 Py_INCREF(Py_None); resultobj = Py_None;
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16018 PyObject *resultobj;
16019 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16020 bool result;
16021 PyObject * obj0 = 0 ;
16022 char *kwnames[] = {
16023 (char *) "self", NULL
16024 };
16025
16026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16028 if (SWIG_arg_fail(1)) SWIG_fail;
16029 {
16030 PyThreadState* __tstate = wxPyBeginAllowThreads();
16031 result = (bool)(arg1)->IsAllowed();
16032
16033 wxPyEndAllowThreads(__tstate);
16034 if (PyErr_Occurred()) SWIG_fail;
16035 }
16036 {
16037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16038 }
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16046 PyObject *obj;
16047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16048 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16049 Py_INCREF(obj);
16050 return Py_BuildValue((char *)"");
16051 }
16052 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj;
16054 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16055 int arg2 = (int) 0 ;
16056 int arg3 = (int) 0 ;
16057 int arg4 = (int) 0 ;
16058 wxScrollEvent *result;
16059 PyObject * obj0 = 0 ;
16060 PyObject * obj1 = 0 ;
16061 PyObject * obj2 = 0 ;
16062 PyObject * obj3 = 0 ;
16063 char *kwnames[] = {
16064 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16065 };
16066
16067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16068 if (obj0) {
16069 {
16070 arg1 = (wxEventType)(SWIG_As_int(obj0));
16071 if (SWIG_arg_fail(1)) SWIG_fail;
16072 }
16073 }
16074 if (obj1) {
16075 {
16076 arg2 = (int)(SWIG_As_int(obj1));
16077 if (SWIG_arg_fail(2)) SWIG_fail;
16078 }
16079 }
16080 if (obj2) {
16081 {
16082 arg3 = (int)(SWIG_As_int(obj2));
16083 if (SWIG_arg_fail(3)) SWIG_fail;
16084 }
16085 }
16086 if (obj3) {
16087 {
16088 arg4 = (int)(SWIG_As_int(obj3));
16089 if (SWIG_arg_fail(4)) SWIG_fail;
16090 }
16091 }
16092 {
16093 PyThreadState* __tstate = wxPyBeginAllowThreads();
16094 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16095
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16100 return resultobj;
16101 fail:
16102 return NULL;
16103 }
16104
16105
16106 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16107 PyObject *resultobj;
16108 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16109 int result;
16110 PyObject * obj0 = 0 ;
16111 char *kwnames[] = {
16112 (char *) "self", NULL
16113 };
16114
16115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16117 if (SWIG_arg_fail(1)) SWIG_fail;
16118 {
16119 PyThreadState* __tstate = wxPyBeginAllowThreads();
16120 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16121
16122 wxPyEndAllowThreads(__tstate);
16123 if (PyErr_Occurred()) SWIG_fail;
16124 }
16125 {
16126 resultobj = SWIG_From_int((int)(result));
16127 }
16128 return resultobj;
16129 fail:
16130 return NULL;
16131 }
16132
16133
16134 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16135 PyObject *resultobj;
16136 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16137 int result;
16138 PyObject * obj0 = 0 ;
16139 char *kwnames[] = {
16140 (char *) "self", NULL
16141 };
16142
16143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16145 if (SWIG_arg_fail(1)) SWIG_fail;
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16149
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 {
16154 resultobj = SWIG_From_int((int)(result));
16155 }
16156 return resultobj;
16157 fail:
16158 return NULL;
16159 }
16160
16161
16162 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16163 PyObject *resultobj;
16164 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16165 int arg2 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 char *kwnames[] = {
16169 (char *) "self",(char *) "orient", NULL
16170 };
16171
16172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16174 if (SWIG_arg_fail(1)) SWIG_fail;
16175 {
16176 arg2 = (int)(SWIG_As_int(obj1));
16177 if (SWIG_arg_fail(2)) SWIG_fail;
16178 }
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 (arg1)->SetOrientation(arg2);
16182
16183 wxPyEndAllowThreads(__tstate);
16184 if (PyErr_Occurred()) SWIG_fail;
16185 }
16186 Py_INCREF(Py_None); resultobj = Py_None;
16187 return resultobj;
16188 fail:
16189 return NULL;
16190 }
16191
16192
16193 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16194 PyObject *resultobj;
16195 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16196 int arg2 ;
16197 PyObject * obj0 = 0 ;
16198 PyObject * obj1 = 0 ;
16199 char *kwnames[] = {
16200 (char *) "self",(char *) "pos", NULL
16201 };
16202
16203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16205 if (SWIG_arg_fail(1)) SWIG_fail;
16206 {
16207 arg2 = (int)(SWIG_As_int(obj1));
16208 if (SWIG_arg_fail(2)) SWIG_fail;
16209 }
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 (arg1)->SetPosition(arg2);
16213
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 Py_INCREF(Py_None); resultobj = Py_None;
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16225 PyObject *obj;
16226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16227 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16228 Py_INCREF(obj);
16229 return Py_BuildValue((char *)"");
16230 }
16231 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj;
16233 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16234 int arg2 = (int) 0 ;
16235 int arg3 = (int) 0 ;
16236 wxScrollWinEvent *result;
16237 PyObject * obj0 = 0 ;
16238 PyObject * obj1 = 0 ;
16239 PyObject * obj2 = 0 ;
16240 char *kwnames[] = {
16241 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16242 };
16243
16244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16245 if (obj0) {
16246 {
16247 arg1 = (wxEventType)(SWIG_As_int(obj0));
16248 if (SWIG_arg_fail(1)) SWIG_fail;
16249 }
16250 }
16251 if (obj1) {
16252 {
16253 arg2 = (int)(SWIG_As_int(obj1));
16254 if (SWIG_arg_fail(2)) SWIG_fail;
16255 }
16256 }
16257 if (obj2) {
16258 {
16259 arg3 = (int)(SWIG_As_int(obj2));
16260 if (SWIG_arg_fail(3)) SWIG_fail;
16261 }
16262 }
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16271 return resultobj;
16272 fail:
16273 return NULL;
16274 }
16275
16276
16277 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16278 PyObject *resultobj;
16279 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16280 int result;
16281 PyObject * obj0 = 0 ;
16282 char *kwnames[] = {
16283 (char *) "self", NULL
16284 };
16285
16286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16288 if (SWIG_arg_fail(1)) SWIG_fail;
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16292
16293 wxPyEndAllowThreads(__tstate);
16294 if (PyErr_Occurred()) SWIG_fail;
16295 }
16296 {
16297 resultobj = SWIG_From_int((int)(result));
16298 }
16299 return resultobj;
16300 fail:
16301 return NULL;
16302 }
16303
16304
16305 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16306 PyObject *resultobj;
16307 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16308 int result;
16309 PyObject * obj0 = 0 ;
16310 char *kwnames[] = {
16311 (char *) "self", NULL
16312 };
16313
16314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16316 if (SWIG_arg_fail(1)) SWIG_fail;
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16320
16321 wxPyEndAllowThreads(__tstate);
16322 if (PyErr_Occurred()) SWIG_fail;
16323 }
16324 {
16325 resultobj = SWIG_From_int((int)(result));
16326 }
16327 return resultobj;
16328 fail:
16329 return NULL;
16330 }
16331
16332
16333 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16334 PyObject *resultobj;
16335 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16336 int arg2 ;
16337 PyObject * obj0 = 0 ;
16338 PyObject * obj1 = 0 ;
16339 char *kwnames[] = {
16340 (char *) "self",(char *) "orient", NULL
16341 };
16342
16343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16345 if (SWIG_arg_fail(1)) SWIG_fail;
16346 {
16347 arg2 = (int)(SWIG_As_int(obj1));
16348 if (SWIG_arg_fail(2)) SWIG_fail;
16349 }
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 (arg1)->SetOrientation(arg2);
16353
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 Py_INCREF(Py_None); resultobj = Py_None;
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16365 PyObject *resultobj;
16366 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16367 int arg2 ;
16368 PyObject * obj0 = 0 ;
16369 PyObject * obj1 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self",(char *) "pos", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 arg2 = (int)(SWIG_As_int(obj1));
16379 if (SWIG_arg_fail(2)) SWIG_fail;
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 (arg1)->SetPosition(arg2);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 Py_INCREF(Py_None); resultobj = Py_None;
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16396 PyObject *obj;
16397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16398 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16399 Py_INCREF(obj);
16400 return Py_BuildValue((char *)"");
16401 }
16402 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16403 PyObject *resultobj;
16404 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16405 wxMouseEvent *result;
16406 PyObject * obj0 = 0 ;
16407 char *kwnames[] = {
16408 (char *) "mouseType", NULL
16409 };
16410
16411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16412 if (obj0) {
16413 {
16414 arg1 = (wxEventType)(SWIG_As_int(obj0));
16415 if (SWIG_arg_fail(1)) SWIG_fail;
16416 }
16417 }
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16421
16422 wxPyEndAllowThreads(__tstate);
16423 if (PyErr_Occurred()) SWIG_fail;
16424 }
16425 {
16426 resultobj = wxPyMake_wxObject(result, 1);
16427 }
16428 return resultobj;
16429 fail:
16430 return NULL;
16431 }
16432
16433
16434 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj;
16436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16437 bool result;
16438 PyObject * obj0 = 0 ;
16439 char *kwnames[] = {
16440 (char *) "self", NULL
16441 };
16442
16443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16445 if (SWIG_arg_fail(1)) SWIG_fail;
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16449
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 {
16454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16455 }
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj;
16464 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16465 int arg2 = (int) wxMOUSE_BTN_ANY ;
16466 bool result;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 char *kwnames[] = {
16470 (char *) "self",(char *) "but", NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16475 if (SWIG_arg_fail(1)) SWIG_fail;
16476 if (obj1) {
16477 {
16478 arg2 = (int)(SWIG_As_int(obj1));
16479 if (SWIG_arg_fail(2)) SWIG_fail;
16480 }
16481 }
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16485
16486 wxPyEndAllowThreads(__tstate);
16487 if (PyErr_Occurred()) SWIG_fail;
16488 }
16489 {
16490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16491 }
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16499 PyObject *resultobj;
16500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16501 int arg2 = (int) wxMOUSE_BTN_ANY ;
16502 bool result;
16503 PyObject * obj0 = 0 ;
16504 PyObject * obj1 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self",(char *) "but", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 if (obj1) {
16513 {
16514 arg2 = (int)(SWIG_As_int(obj1));
16515 if (SWIG_arg_fail(2)) SWIG_fail;
16516 }
16517 }
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16521
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 {
16526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16527 }
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj;
16536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16537 int arg2 = (int) wxMOUSE_BTN_ANY ;
16538 bool result;
16539 PyObject * obj0 = 0 ;
16540 PyObject * obj1 = 0 ;
16541 char *kwnames[] = {
16542 (char *) "self",(char *) "but", NULL
16543 };
16544
16545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16547 if (SWIG_arg_fail(1)) SWIG_fail;
16548 if (obj1) {
16549 {
16550 arg2 = (int)(SWIG_As_int(obj1));
16551 if (SWIG_arg_fail(2)) SWIG_fail;
16552 }
16553 }
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 {
16562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16563 }
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj;
16572 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16573 int arg2 ;
16574 bool result;
16575 PyObject * obj0 = 0 ;
16576 PyObject * obj1 = 0 ;
16577 char *kwnames[] = {
16578 (char *) "self",(char *) "button", NULL
16579 };
16580
16581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16583 if (SWIG_arg_fail(1)) SWIG_fail;
16584 {
16585 arg2 = (int)(SWIG_As_int(obj1));
16586 if (SWIG_arg_fail(2)) SWIG_fail;
16587 }
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16591
16592 wxPyEndAllowThreads(__tstate);
16593 if (PyErr_Occurred()) SWIG_fail;
16594 }
16595 {
16596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16597 }
16598 return resultobj;
16599 fail:
16600 return NULL;
16601 }
16602
16603
16604 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj;
16606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16607 int arg2 ;
16608 bool result;
16609 PyObject * obj0 = 0 ;
16610 PyObject * obj1 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "self",(char *) "but", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16617 if (SWIG_arg_fail(1)) SWIG_fail;
16618 {
16619 arg2 = (int)(SWIG_As_int(obj1));
16620 if (SWIG_arg_fail(2)) SWIG_fail;
16621 }
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16625
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 {
16630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16631 }
16632 return resultobj;
16633 fail:
16634 return NULL;
16635 }
16636
16637
16638 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16639 PyObject *resultobj;
16640 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16641 int result;
16642 PyObject * obj0 = 0 ;
16643 char *kwnames[] = {
16644 (char *) "self", NULL
16645 };
16646
16647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16649 if (SWIG_arg_fail(1)) SWIG_fail;
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16653
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 {
16658 resultobj = SWIG_From_int((int)(result));
16659 }
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj;
16668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16669 bool result;
16670 PyObject * obj0 = 0 ;
16671 char *kwnames[] = {
16672 (char *) "self", NULL
16673 };
16674
16675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16677 if (SWIG_arg_fail(1)) SWIG_fail;
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16681
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 {
16686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16687 }
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj;
16696 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16697 bool result;
16698 PyObject * obj0 = 0 ;
16699 char *kwnames[] = {
16700 (char *) "self", NULL
16701 };
16702
16703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16705 if (SWIG_arg_fail(1)) SWIG_fail;
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16715 }
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj;
16724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16725 bool result;
16726 PyObject * obj0 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16743 }
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj;
16752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16753 bool result;
16754 PyObject * obj0 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 {
16770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16771 }
16772 return resultobj;
16773 fail:
16774 return NULL;
16775 }
16776
16777
16778 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16779 PyObject *resultobj;
16780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16781 bool result;
16782 PyObject * obj0 = 0 ;
16783 char *kwnames[] = {
16784 (char *) "self", NULL
16785 };
16786
16787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16789 if (SWIG_arg_fail(1)) SWIG_fail;
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16793
16794 wxPyEndAllowThreads(__tstate);
16795 if (PyErr_Occurred()) SWIG_fail;
16796 }
16797 {
16798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16799 }
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj;
16808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16809 bool result;
16810 PyObject * obj0 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "self", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16817 if (SWIG_arg_fail(1)) SWIG_fail;
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 {
16826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16827 }
16828 return resultobj;
16829 fail:
16830 return NULL;
16831 }
16832
16833
16834 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16835 PyObject *resultobj;
16836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16837 bool result;
16838 PyObject * obj0 = 0 ;
16839 char *kwnames[] = {
16840 (char *) "self", NULL
16841 };
16842
16843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16845 if (SWIG_arg_fail(1)) SWIG_fail;
16846 {
16847 PyThreadState* __tstate = wxPyBeginAllowThreads();
16848 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16849
16850 wxPyEndAllowThreads(__tstate);
16851 if (PyErr_Occurred()) SWIG_fail;
16852 }
16853 {
16854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16855 }
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16865 bool result;
16866 PyObject * obj0 = 0 ;
16867 char *kwnames[] = {
16868 (char *) "self", NULL
16869 };
16870
16871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16873 if (SWIG_arg_fail(1)) SWIG_fail;
16874 {
16875 PyThreadState* __tstate = wxPyBeginAllowThreads();
16876 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16877
16878 wxPyEndAllowThreads(__tstate);
16879 if (PyErr_Occurred()) SWIG_fail;
16880 }
16881 {
16882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj;
16892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16893 bool result;
16894 PyObject * obj0 = 0 ;
16895 char *kwnames[] = {
16896 (char *) "self", NULL
16897 };
16898
16899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16901 if (SWIG_arg_fail(1)) SWIG_fail;
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16905
16906 wxPyEndAllowThreads(__tstate);
16907 if (PyErr_Occurred()) SWIG_fail;
16908 }
16909 {
16910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16911 }
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16919 PyObject *resultobj;
16920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16921 bool result;
16922 PyObject * obj0 = 0 ;
16923 char *kwnames[] = {
16924 (char *) "self", NULL
16925 };
16926
16927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16929 if (SWIG_arg_fail(1)) SWIG_fail;
16930 {
16931 PyThreadState* __tstate = wxPyBeginAllowThreads();
16932 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16933
16934 wxPyEndAllowThreads(__tstate);
16935 if (PyErr_Occurred()) SWIG_fail;
16936 }
16937 {
16938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16939 }
16940 return resultobj;
16941 fail:
16942 return NULL;
16943 }
16944
16945
16946 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16947 PyObject *resultobj;
16948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16949 bool result;
16950 PyObject * obj0 = 0 ;
16951 char *kwnames[] = {
16952 (char *) "self", NULL
16953 };
16954
16955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16957 if (SWIG_arg_fail(1)) SWIG_fail;
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16961
16962 wxPyEndAllowThreads(__tstate);
16963 if (PyErr_Occurred()) SWIG_fail;
16964 }
16965 {
16966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16967 }
16968 return resultobj;
16969 fail:
16970 return NULL;
16971 }
16972
16973
16974 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16975 PyObject *resultobj;
16976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16977 bool result;
16978 PyObject * obj0 = 0 ;
16979 char *kwnames[] = {
16980 (char *) "self", NULL
16981 };
16982
16983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16985 if (SWIG_arg_fail(1)) SWIG_fail;
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16989
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj;
17004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17005 bool result;
17006 PyObject * obj0 = 0 ;
17007 char *kwnames[] = {
17008 (char *) "self", NULL
17009 };
17010
17011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17013 if (SWIG_arg_fail(1)) SWIG_fail;
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17017
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 {
17022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17023 }
17024 return resultobj;
17025 fail:
17026 return NULL;
17027 }
17028
17029
17030 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17031 PyObject *resultobj;
17032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17033 bool result;
17034 PyObject * obj0 = 0 ;
17035 char *kwnames[] = {
17036 (char *) "self", NULL
17037 };
17038
17039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17041 if (SWIG_arg_fail(1)) SWIG_fail;
17042 {
17043 PyThreadState* __tstate = wxPyBeginAllowThreads();
17044 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17045
17046 wxPyEndAllowThreads(__tstate);
17047 if (PyErr_Occurred()) SWIG_fail;
17048 }
17049 {
17050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17051 }
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj;
17060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17061 bool result;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (bool)(arg1)->LeftIsDown();
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 {
17078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17079 }
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17089 bool result;
17090 PyObject * obj0 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (bool)(arg1)->MiddleIsDown();
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj;
17116 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17117 bool result;
17118 PyObject * obj0 = 0 ;
17119 char *kwnames[] = {
17120 (char *) "self", NULL
17121 };
17122
17123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17125 if (SWIG_arg_fail(1)) SWIG_fail;
17126 {
17127 PyThreadState* __tstate = wxPyBeginAllowThreads();
17128 result = (bool)(arg1)->RightIsDown();
17129
17130 wxPyEndAllowThreads(__tstate);
17131 if (PyErr_Occurred()) SWIG_fail;
17132 }
17133 {
17134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17135 }
17136 return resultobj;
17137 fail:
17138 return NULL;
17139 }
17140
17141
17142 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj;
17144 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17145 bool result;
17146 PyObject * obj0 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 {
17162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17163 }
17164 return resultobj;
17165 fail:
17166 return NULL;
17167 }
17168
17169
17170 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17171 PyObject *resultobj;
17172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17173 bool result;
17174 PyObject * obj0 = 0 ;
17175 char *kwnames[] = {
17176 (char *) "self", NULL
17177 };
17178
17179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17181 if (SWIG_arg_fail(1)) SWIG_fail;
17182 {
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17185
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 {
17190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17191 }
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17201 bool result;
17202 PyObject * obj0 = 0 ;
17203 char *kwnames[] = {
17204 (char *) "self", NULL
17205 };
17206
17207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17209 if (SWIG_arg_fail(1)) SWIG_fail;
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17213
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 {
17218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17229 bool result;
17230 PyObject * obj0 = 0 ;
17231 char *kwnames[] = {
17232 (char *) "self", NULL
17233 };
17234
17235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17237 if (SWIG_arg_fail(1)) SWIG_fail;
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17241
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 {
17246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17247 }
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 wxPoint result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (arg1)->GetPosition();
17269
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 wxPoint * resultptr;
17275 resultptr = new wxPoint((wxPoint &)(result));
17276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17277 }
17278 return resultobj;
17279 fail:
17280 return NULL;
17281 }
17282
17283
17284 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17285 PyObject *resultobj;
17286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17287 long *arg2 = (long *) 0 ;
17288 long *arg3 = (long *) 0 ;
17289 long temp2 ;
17290 int res2 = 0 ;
17291 long temp3 ;
17292 int res3 = 0 ;
17293 PyObject * obj0 = 0 ;
17294 char *kwnames[] = {
17295 (char *) "self", NULL
17296 };
17297
17298 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17299 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17302 if (SWIG_arg_fail(1)) SWIG_fail;
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 (arg1)->GetPosition(arg2,arg3);
17306
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 Py_INCREF(Py_None); resultobj = Py_None;
17311 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17312 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17313 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17314 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17322 PyObject *resultobj;
17323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17324 wxDC *arg2 = 0 ;
17325 wxPoint result;
17326 PyObject * obj0 = 0 ;
17327 PyObject * obj1 = 0 ;
17328 char *kwnames[] = {
17329 (char *) "self",(char *) "dc", NULL
17330 };
17331
17332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17334 if (SWIG_arg_fail(1)) SWIG_fail;
17335 {
17336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17337 if (SWIG_arg_fail(2)) SWIG_fail;
17338 if (arg2 == NULL) {
17339 SWIG_null_ref("wxDC");
17340 }
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 }
17343 {
17344 PyThreadState* __tstate = wxPyBeginAllowThreads();
17345 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17346
17347 wxPyEndAllowThreads(__tstate);
17348 if (PyErr_Occurred()) SWIG_fail;
17349 }
17350 {
17351 wxPoint * resultptr;
17352 resultptr = new wxPoint((wxPoint &)(result));
17353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17354 }
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17362 PyObject *resultobj;
17363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17364 int result;
17365 PyObject * obj0 = 0 ;
17366 char *kwnames[] = {
17367 (char *) "self", NULL
17368 };
17369
17370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17372 if (SWIG_arg_fail(1)) SWIG_fail;
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (int)((wxMouseEvent const *)arg1)->GetX();
17376
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 {
17381 resultobj = SWIG_From_int((int)(result));
17382 }
17383 return resultobj;
17384 fail:
17385 return NULL;
17386 }
17387
17388
17389 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17390 PyObject *resultobj;
17391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17392 int result;
17393 PyObject * obj0 = 0 ;
17394 char *kwnames[] = {
17395 (char *) "self", NULL
17396 };
17397
17398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17400 if (SWIG_arg_fail(1)) SWIG_fail;
17401 {
17402 PyThreadState* __tstate = wxPyBeginAllowThreads();
17403 result = (int)((wxMouseEvent const *)arg1)->GetY();
17404
17405 wxPyEndAllowThreads(__tstate);
17406 if (PyErr_Occurred()) SWIG_fail;
17407 }
17408 {
17409 resultobj = SWIG_From_int((int)(result));
17410 }
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17420 int result;
17421 PyObject * obj0 = 0 ;
17422 char *kwnames[] = {
17423 (char *) "self", NULL
17424 };
17425
17426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17428 if (SWIG_arg_fail(1)) SWIG_fail;
17429 {
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17432
17433 wxPyEndAllowThreads(__tstate);
17434 if (PyErr_Occurred()) SWIG_fail;
17435 }
17436 {
17437 resultobj = SWIG_From_int((int)(result));
17438 }
17439 return resultobj;
17440 fail:
17441 return NULL;
17442 }
17443
17444
17445 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17446 PyObject *resultobj;
17447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17448 int result;
17449 PyObject * obj0 = 0 ;
17450 char *kwnames[] = {
17451 (char *) "self", NULL
17452 };
17453
17454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17456 if (SWIG_arg_fail(1)) SWIG_fail;
17457 {
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17460
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 {
17465 resultobj = SWIG_From_int((int)(result));
17466 }
17467 return resultobj;
17468 fail:
17469 return NULL;
17470 }
17471
17472
17473 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj;
17475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17476 int result;
17477 PyObject * obj0 = 0 ;
17478 char *kwnames[] = {
17479 (char *) "self", NULL
17480 };
17481
17482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17484 if (SWIG_arg_fail(1)) SWIG_fail;
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17488
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 {
17493 resultobj = SWIG_From_int((int)(result));
17494 }
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17504 bool result;
17505 PyObject * obj0 = 0 ;
17506 char *kwnames[] = {
17507 (char *) "self", NULL
17508 };
17509
17510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17512 if (SWIG_arg_fail(1)) SWIG_fail;
17513 {
17514 PyThreadState* __tstate = wxPyBeginAllowThreads();
17515 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17516
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 {
17521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17522 }
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17530 PyObject *resultobj;
17531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17532 int arg2 ;
17533 PyObject * obj0 = 0 ;
17534 PyObject * obj1 = 0 ;
17535 char *kwnames[] = {
17536 (char *) "self",(char *) "m_x", NULL
17537 };
17538
17539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17541 if (SWIG_arg_fail(1)) SWIG_fail;
17542 {
17543 arg2 = (int)(SWIG_As_int(obj1));
17544 if (SWIG_arg_fail(2)) SWIG_fail;
17545 }
17546 if (arg1) (arg1)->m_x = arg2;
17547
17548 Py_INCREF(Py_None); resultobj = Py_None;
17549 return resultobj;
17550 fail:
17551 return NULL;
17552 }
17553
17554
17555 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj;
17557 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17558 int result;
17559 PyObject * obj0 = 0 ;
17560 char *kwnames[] = {
17561 (char *) "self", NULL
17562 };
17563
17564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17566 if (SWIG_arg_fail(1)) SWIG_fail;
17567 result = (int) ((arg1)->m_x);
17568
17569 {
17570 resultobj = SWIG_From_int((int)(result));
17571 }
17572 return resultobj;
17573 fail:
17574 return NULL;
17575 }
17576
17577
17578 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17579 PyObject *resultobj;
17580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17581 int arg2 ;
17582 PyObject * obj0 = 0 ;
17583 PyObject * obj1 = 0 ;
17584 char *kwnames[] = {
17585 (char *) "self",(char *) "m_y", NULL
17586 };
17587
17588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17590 if (SWIG_arg_fail(1)) SWIG_fail;
17591 {
17592 arg2 = (int)(SWIG_As_int(obj1));
17593 if (SWIG_arg_fail(2)) SWIG_fail;
17594 }
17595 if (arg1) (arg1)->m_y = arg2;
17596
17597 Py_INCREF(Py_None); resultobj = Py_None;
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17605 PyObject *resultobj;
17606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17607 int result;
17608 PyObject * obj0 = 0 ;
17609 char *kwnames[] = {
17610 (char *) "self", NULL
17611 };
17612
17613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17615 if (SWIG_arg_fail(1)) SWIG_fail;
17616 result = (int) ((arg1)->m_y);
17617
17618 {
17619 resultobj = SWIG_From_int((int)(result));
17620 }
17621 return resultobj;
17622 fail:
17623 return NULL;
17624 }
17625
17626
17627 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17630 bool arg2 ;
17631 PyObject * obj0 = 0 ;
17632 PyObject * obj1 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "self",(char *) "m_leftDown", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 arg2 = (bool)(SWIG_As_bool(obj1));
17642 if (SWIG_arg_fail(2)) SWIG_fail;
17643 }
17644 if (arg1) (arg1)->m_leftDown = arg2;
17645
17646 Py_INCREF(Py_None); resultobj = Py_None;
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17656 bool result;
17657 PyObject * obj0 = 0 ;
17658 char *kwnames[] = {
17659 (char *) "self", NULL
17660 };
17661
17662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 result = (bool) ((arg1)->m_leftDown);
17666
17667 {
17668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17669 }
17670 return resultobj;
17671 fail:
17672 return NULL;
17673 }
17674
17675
17676 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj;
17678 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17679 bool arg2 ;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 char *kwnames[] = {
17683 (char *) "self",(char *) "m_middleDown", NULL
17684 };
17685
17686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17688 if (SWIG_arg_fail(1)) SWIG_fail;
17689 {
17690 arg2 = (bool)(SWIG_As_bool(obj1));
17691 if (SWIG_arg_fail(2)) SWIG_fail;
17692 }
17693 if (arg1) (arg1)->m_middleDown = arg2;
17694
17695 Py_INCREF(Py_None); resultobj = Py_None;
17696 return resultobj;
17697 fail:
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17705 bool result;
17706 PyObject * obj0 = 0 ;
17707 char *kwnames[] = {
17708 (char *) "self", NULL
17709 };
17710
17711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17713 if (SWIG_arg_fail(1)) SWIG_fail;
17714 result = (bool) ((arg1)->m_middleDown);
17715
17716 {
17717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17718 }
17719 return resultobj;
17720 fail:
17721 return NULL;
17722 }
17723
17724
17725 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17726 PyObject *resultobj;
17727 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17728 bool arg2 ;
17729 PyObject * obj0 = 0 ;
17730 PyObject * obj1 = 0 ;
17731 char *kwnames[] = {
17732 (char *) "self",(char *) "m_rightDown", NULL
17733 };
17734
17735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17737 if (SWIG_arg_fail(1)) SWIG_fail;
17738 {
17739 arg2 = (bool)(SWIG_As_bool(obj1));
17740 if (SWIG_arg_fail(2)) SWIG_fail;
17741 }
17742 if (arg1) (arg1)->m_rightDown = arg2;
17743
17744 Py_INCREF(Py_None); resultobj = Py_None;
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17754 bool result;
17755 PyObject * obj0 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "self", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17762 if (SWIG_arg_fail(1)) SWIG_fail;
17763 result = (bool) ((arg1)->m_rightDown);
17764
17765 {
17766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17767 }
17768 return resultobj;
17769 fail:
17770 return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17777 bool arg2 ;
17778 PyObject * obj0 = 0 ;
17779 PyObject * obj1 = 0 ;
17780 char *kwnames[] = {
17781 (char *) "self",(char *) "m_controlDown", NULL
17782 };
17783
17784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17786 if (SWIG_arg_fail(1)) SWIG_fail;
17787 {
17788 arg2 = (bool)(SWIG_As_bool(obj1));
17789 if (SWIG_arg_fail(2)) SWIG_fail;
17790 }
17791 if (arg1) (arg1)->m_controlDown = arg2;
17792
17793 Py_INCREF(Py_None); resultobj = Py_None;
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj;
17802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17803 bool result;
17804 PyObject * obj0 = 0 ;
17805 char *kwnames[] = {
17806 (char *) "self", NULL
17807 };
17808
17809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17811 if (SWIG_arg_fail(1)) SWIG_fail;
17812 result = (bool) ((arg1)->m_controlDown);
17813
17814 {
17815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17816 }
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj;
17825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17826 bool arg2 ;
17827 PyObject * obj0 = 0 ;
17828 PyObject * obj1 = 0 ;
17829 char *kwnames[] = {
17830 (char *) "self",(char *) "m_shiftDown", NULL
17831 };
17832
17833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17835 if (SWIG_arg_fail(1)) SWIG_fail;
17836 {
17837 arg2 = (bool)(SWIG_As_bool(obj1));
17838 if (SWIG_arg_fail(2)) SWIG_fail;
17839 }
17840 if (arg1) (arg1)->m_shiftDown = arg2;
17841
17842 Py_INCREF(Py_None); resultobj = Py_None;
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj;
17851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17852 bool result;
17853 PyObject * obj0 = 0 ;
17854 char *kwnames[] = {
17855 (char *) "self", NULL
17856 };
17857
17858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17860 if (SWIG_arg_fail(1)) SWIG_fail;
17861 result = (bool) ((arg1)->m_shiftDown);
17862
17863 {
17864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj;
17874 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17875 bool arg2 ;
17876 PyObject * obj0 = 0 ;
17877 PyObject * obj1 = 0 ;
17878 char *kwnames[] = {
17879 (char *) "self",(char *) "m_altDown", NULL
17880 };
17881
17882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 {
17886 arg2 = (bool)(SWIG_As_bool(obj1));
17887 if (SWIG_arg_fail(2)) SWIG_fail;
17888 }
17889 if (arg1) (arg1)->m_altDown = arg2;
17890
17891 Py_INCREF(Py_None); resultobj = Py_None;
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17899 PyObject *resultobj;
17900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17901 bool result;
17902 PyObject * obj0 = 0 ;
17903 char *kwnames[] = {
17904 (char *) "self", NULL
17905 };
17906
17907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17909 if (SWIG_arg_fail(1)) SWIG_fail;
17910 result = (bool) ((arg1)->m_altDown);
17911
17912 {
17913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17914 }
17915 return resultobj;
17916 fail:
17917 return NULL;
17918 }
17919
17920
17921 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj;
17923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17924 bool arg2 ;
17925 PyObject * obj0 = 0 ;
17926 PyObject * obj1 = 0 ;
17927 char *kwnames[] = {
17928 (char *) "self",(char *) "m_metaDown", NULL
17929 };
17930
17931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17933 if (SWIG_arg_fail(1)) SWIG_fail;
17934 {
17935 arg2 = (bool)(SWIG_As_bool(obj1));
17936 if (SWIG_arg_fail(2)) SWIG_fail;
17937 }
17938 if (arg1) (arg1)->m_metaDown = arg2;
17939
17940 Py_INCREF(Py_None); resultobj = Py_None;
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17948 PyObject *resultobj;
17949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17950 bool result;
17951 PyObject * obj0 = 0 ;
17952 char *kwnames[] = {
17953 (char *) "self", NULL
17954 };
17955
17956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17958 if (SWIG_arg_fail(1)) SWIG_fail;
17959 result = (bool) ((arg1)->m_metaDown);
17960
17961 {
17962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17963 }
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj;
17972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17973 int arg2 ;
17974 PyObject * obj0 = 0 ;
17975 PyObject * obj1 = 0 ;
17976 char *kwnames[] = {
17977 (char *) "self",(char *) "m_wheelRotation", NULL
17978 };
17979
17980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17982 if (SWIG_arg_fail(1)) SWIG_fail;
17983 {
17984 arg2 = (int)(SWIG_As_int(obj1));
17985 if (SWIG_arg_fail(2)) SWIG_fail;
17986 }
17987 if (arg1) (arg1)->m_wheelRotation = arg2;
17988
17989 Py_INCREF(Py_None); resultobj = Py_None;
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj;
17998 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17999 int result;
18000 PyObject * obj0 = 0 ;
18001 char *kwnames[] = {
18002 (char *) "self", NULL
18003 };
18004
18005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18007 if (SWIG_arg_fail(1)) SWIG_fail;
18008 result = (int) ((arg1)->m_wheelRotation);
18009
18010 {
18011 resultobj = SWIG_From_int((int)(result));
18012 }
18013 return resultobj;
18014 fail:
18015 return NULL;
18016 }
18017
18018
18019 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj;
18021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18022 int arg2 ;
18023 PyObject * obj0 = 0 ;
18024 PyObject * obj1 = 0 ;
18025 char *kwnames[] = {
18026 (char *) "self",(char *) "m_wheelDelta", NULL
18027 };
18028
18029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18031 if (SWIG_arg_fail(1)) SWIG_fail;
18032 {
18033 arg2 = (int)(SWIG_As_int(obj1));
18034 if (SWIG_arg_fail(2)) SWIG_fail;
18035 }
18036 if (arg1) (arg1)->m_wheelDelta = arg2;
18037
18038 Py_INCREF(Py_None); resultobj = Py_None;
18039 return resultobj;
18040 fail:
18041 return NULL;
18042 }
18043
18044
18045 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18046 PyObject *resultobj;
18047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18048 int result;
18049 PyObject * obj0 = 0 ;
18050 char *kwnames[] = {
18051 (char *) "self", NULL
18052 };
18053
18054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18056 if (SWIG_arg_fail(1)) SWIG_fail;
18057 result = (int) ((arg1)->m_wheelDelta);
18058
18059 {
18060 resultobj = SWIG_From_int((int)(result));
18061 }
18062 return resultobj;
18063 fail:
18064 return NULL;
18065 }
18066
18067
18068 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj;
18070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18071 int arg2 ;
18072 PyObject * obj0 = 0 ;
18073 PyObject * obj1 = 0 ;
18074 char *kwnames[] = {
18075 (char *) "self",(char *) "m_linesPerAction", NULL
18076 };
18077
18078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18080 if (SWIG_arg_fail(1)) SWIG_fail;
18081 {
18082 arg2 = (int)(SWIG_As_int(obj1));
18083 if (SWIG_arg_fail(2)) SWIG_fail;
18084 }
18085 if (arg1) (arg1)->m_linesPerAction = arg2;
18086
18087 Py_INCREF(Py_None); resultobj = Py_None;
18088 return resultobj;
18089 fail:
18090 return NULL;
18091 }
18092
18093
18094 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18095 PyObject *resultobj;
18096 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18097 int result;
18098 PyObject * obj0 = 0 ;
18099 char *kwnames[] = {
18100 (char *) "self", NULL
18101 };
18102
18103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18105 if (SWIG_arg_fail(1)) SWIG_fail;
18106 result = (int) ((arg1)->m_linesPerAction);
18107
18108 {
18109 resultobj = SWIG_From_int((int)(result));
18110 }
18111 return resultobj;
18112 fail:
18113 return NULL;
18114 }
18115
18116
18117 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18118 PyObject *obj;
18119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18120 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18121 Py_INCREF(obj);
18122 return Py_BuildValue((char *)"");
18123 }
18124 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18125 PyObject *resultobj;
18126 int arg1 = (int) 0 ;
18127 int arg2 = (int) 0 ;
18128 wxSetCursorEvent *result;
18129 PyObject * obj0 = 0 ;
18130 PyObject * obj1 = 0 ;
18131 char *kwnames[] = {
18132 (char *) "x",(char *) "y", NULL
18133 };
18134
18135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18136 if (obj0) {
18137 {
18138 arg1 = (int)(SWIG_As_int(obj0));
18139 if (SWIG_arg_fail(1)) SWIG_fail;
18140 }
18141 }
18142 if (obj1) {
18143 {
18144 arg2 = (int)(SWIG_As_int(obj1));
18145 if (SWIG_arg_fail(2)) SWIG_fail;
18146 }
18147 }
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18151
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj;
18164 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18165 int result;
18166 PyObject * obj0 = 0 ;
18167 char *kwnames[] = {
18168 (char *) "self", NULL
18169 };
18170
18171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18173 if (SWIG_arg_fail(1)) SWIG_fail;
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18177
18178 wxPyEndAllowThreads(__tstate);
18179 if (PyErr_Occurred()) SWIG_fail;
18180 }
18181 {
18182 resultobj = SWIG_From_int((int)(result));
18183 }
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18191 PyObject *resultobj;
18192 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18193 int result;
18194 PyObject * obj0 = 0 ;
18195 char *kwnames[] = {
18196 (char *) "self", NULL
18197 };
18198
18199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18201 if (SWIG_arg_fail(1)) SWIG_fail;
18202 {
18203 PyThreadState* __tstate = wxPyBeginAllowThreads();
18204 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18205
18206 wxPyEndAllowThreads(__tstate);
18207 if (PyErr_Occurred()) SWIG_fail;
18208 }
18209 {
18210 resultobj = SWIG_From_int((int)(result));
18211 }
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18219 PyObject *resultobj;
18220 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18221 wxCursor *arg2 = 0 ;
18222 PyObject * obj0 = 0 ;
18223 PyObject * obj1 = 0 ;
18224 char *kwnames[] = {
18225 (char *) "self",(char *) "cursor", NULL
18226 };
18227
18228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18230 if (SWIG_arg_fail(1)) SWIG_fail;
18231 {
18232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18233 if (SWIG_arg_fail(2)) SWIG_fail;
18234 if (arg2 == NULL) {
18235 SWIG_null_ref("wxCursor");
18236 }
18237 if (SWIG_arg_fail(2)) SWIG_fail;
18238 }
18239 {
18240 PyThreadState* __tstate = wxPyBeginAllowThreads();
18241 (arg1)->SetCursor((wxCursor const &)*arg2);
18242
18243 wxPyEndAllowThreads(__tstate);
18244 if (PyErr_Occurred()) SWIG_fail;
18245 }
18246 Py_INCREF(Py_None); resultobj = Py_None;
18247 return resultobj;
18248 fail:
18249 return NULL;
18250 }
18251
18252
18253 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18254 PyObject *resultobj;
18255 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18256 wxCursor *result;
18257 PyObject * obj0 = 0 ;
18258 char *kwnames[] = {
18259 (char *) "self", NULL
18260 };
18261
18262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18264 if (SWIG_arg_fail(1)) SWIG_fail;
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 {
18268 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18269 result = (wxCursor *) &_result_ref;
18270 }
18271
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 {
18276 wxCursor* resultptr = new wxCursor(*result);
18277 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18278 }
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18286 PyObject *resultobj;
18287 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18288 bool result;
18289 PyObject * obj0 = 0 ;
18290 char *kwnames[] = {
18291 (char *) "self", NULL
18292 };
18293
18294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18296 if (SWIG_arg_fail(1)) SWIG_fail;
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18300
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 {
18305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18306 }
18307 return resultobj;
18308 fail:
18309 return NULL;
18310 }
18311
18312
18313 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18314 PyObject *obj;
18315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18316 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18317 Py_INCREF(obj);
18318 return Py_BuildValue((char *)"");
18319 }
18320 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj;
18322 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18323 wxKeyEvent *result;
18324 PyObject * obj0 = 0 ;
18325 char *kwnames[] = {
18326 (char *) "keyType", NULL
18327 };
18328
18329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18330 if (obj0) {
18331 {
18332 arg1 = (wxEventType)(SWIG_As_int(obj0));
18333 if (SWIG_arg_fail(1)) SWIG_fail;
18334 }
18335 }
18336 {
18337 PyThreadState* __tstate = wxPyBeginAllowThreads();
18338 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18339
18340 wxPyEndAllowThreads(__tstate);
18341 if (PyErr_Occurred()) SWIG_fail;
18342 }
18343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18344 return resultobj;
18345 fail:
18346 return NULL;
18347 }
18348
18349
18350 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18351 PyObject *resultobj;
18352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18353 bool result;
18354 PyObject * obj0 = 0 ;
18355 char *kwnames[] = {
18356 (char *) "self", NULL
18357 };
18358
18359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18361 if (SWIG_arg_fail(1)) SWIG_fail;
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18365
18366 wxPyEndAllowThreads(__tstate);
18367 if (PyErr_Occurred()) SWIG_fail;
18368 }
18369 {
18370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18371 }
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18381 bool result;
18382 PyObject * obj0 = 0 ;
18383 char *kwnames[] = {
18384 (char *) "self", NULL
18385 };
18386
18387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18389 if (SWIG_arg_fail(1)) SWIG_fail;
18390 {
18391 PyThreadState* __tstate = wxPyBeginAllowThreads();
18392 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18393
18394 wxPyEndAllowThreads(__tstate);
18395 if (PyErr_Occurred()) SWIG_fail;
18396 }
18397 {
18398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18399 }
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj;
18408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18409 bool result;
18410 PyObject * obj0 = 0 ;
18411 char *kwnames[] = {
18412 (char *) "self", NULL
18413 };
18414
18415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18417 if (SWIG_arg_fail(1)) SWIG_fail;
18418 {
18419 PyThreadState* __tstate = wxPyBeginAllowThreads();
18420 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18421
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 {
18426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18427 }
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj;
18436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18437 bool result;
18438 PyObject * obj0 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "self", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18445 if (SWIG_arg_fail(1)) SWIG_fail;
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18449
18450 wxPyEndAllowThreads(__tstate);
18451 if (PyErr_Occurred()) SWIG_fail;
18452 }
18453 {
18454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18455 }
18456 return resultobj;
18457 fail:
18458 return NULL;
18459 }
18460
18461
18462 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18463 PyObject *resultobj;
18464 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18465 bool result;
18466 PyObject * obj0 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 PyThreadState* __tstate = wxPyBeginAllowThreads();
18476 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18477
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 {
18482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18483 }
18484 return resultobj;
18485 fail:
18486 return NULL;
18487 }
18488
18489
18490 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18491 PyObject *resultobj;
18492 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18493 bool result;
18494 PyObject * obj0 = 0 ;
18495 char *kwnames[] = {
18496 (char *) "self", NULL
18497 };
18498
18499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18501 if (SWIG_arg_fail(1)) SWIG_fail;
18502 {
18503 PyThreadState* __tstate = wxPyBeginAllowThreads();
18504 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18505
18506 wxPyEndAllowThreads(__tstate);
18507 if (PyErr_Occurred()) SWIG_fail;
18508 }
18509 {
18510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18511 }
18512 return resultobj;
18513 fail:
18514 return NULL;
18515 }
18516
18517
18518 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18519 PyObject *resultobj;
18520 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18521 int result;
18522 PyObject * obj0 = 0 ;
18523 char *kwnames[] = {
18524 (char *) "self", NULL
18525 };
18526
18527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18529 if (SWIG_arg_fail(1)) SWIG_fail;
18530 {
18531 PyThreadState* __tstate = wxPyBeginAllowThreads();
18532 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18533
18534 wxPyEndAllowThreads(__tstate);
18535 if (PyErr_Occurred()) SWIG_fail;
18536 }
18537 {
18538 resultobj = SWIG_From_int((int)(result));
18539 }
18540 return resultobj;
18541 fail:
18542 return NULL;
18543 }
18544
18545
18546 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18547 PyObject *resultobj;
18548 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18549 int result;
18550 PyObject * obj0 = 0 ;
18551 char *kwnames[] = {
18552 (char *) "self", NULL
18553 };
18554
18555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18557 if (SWIG_arg_fail(1)) SWIG_fail;
18558 {
18559 PyThreadState* __tstate = wxPyBeginAllowThreads();
18560 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18561
18562 wxPyEndAllowThreads(__tstate);
18563 if (PyErr_Occurred()) SWIG_fail;
18564 }
18565 {
18566 resultobj = SWIG_From_int((int)(result));
18567 }
18568 return resultobj;
18569 fail:
18570 return NULL;
18571 }
18572
18573
18574 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18575 PyObject *resultobj;
18576 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18577 unsigned int result;
18578 PyObject * obj0 = 0 ;
18579 char *kwnames[] = {
18580 (char *) "self", NULL
18581 };
18582
18583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18585 if (SWIG_arg_fail(1)) SWIG_fail;
18586 {
18587 PyThreadState* __tstate = wxPyBeginAllowThreads();
18588 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18589
18590 wxPyEndAllowThreads(__tstate);
18591 if (PyErr_Occurred()) SWIG_fail;
18592 }
18593 {
18594 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18595 }
18596 return resultobj;
18597 fail:
18598 return NULL;
18599 }
18600
18601
18602 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18603 PyObject *resultobj;
18604 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18605 unsigned int result;
18606 PyObject * obj0 = 0 ;
18607 char *kwnames[] = {
18608 (char *) "self", NULL
18609 };
18610
18611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18613 if (SWIG_arg_fail(1)) SWIG_fail;
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18617
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 {
18622 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18623 }
18624 return resultobj;
18625 fail:
18626 return NULL;
18627 }
18628
18629
18630 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18631 PyObject *resultobj;
18632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18633 wxPoint result;
18634 PyObject * obj0 = 0 ;
18635 char *kwnames[] = {
18636 (char *) "self", NULL
18637 };
18638
18639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18641 if (SWIG_arg_fail(1)) SWIG_fail;
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 result = (arg1)->GetPosition();
18645
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 {
18650 wxPoint * resultptr;
18651 resultptr = new wxPoint((wxPoint &)(result));
18652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18653 }
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18661 PyObject *resultobj;
18662 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18663 long *arg2 = (long *) 0 ;
18664 long *arg3 = (long *) 0 ;
18665 long temp2 ;
18666 int res2 = 0 ;
18667 long temp3 ;
18668 int res3 = 0 ;
18669 PyObject * obj0 = 0 ;
18670 char *kwnames[] = {
18671 (char *) "self", NULL
18672 };
18673
18674 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18675 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18678 if (SWIG_arg_fail(1)) SWIG_fail;
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 (arg1)->GetPosition(arg2,arg3);
18682
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 Py_INCREF(Py_None); resultobj = Py_None;
18687 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18688 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18689 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18690 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18698 PyObject *resultobj;
18699 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18700 int result;
18701 PyObject * obj0 = 0 ;
18702 char *kwnames[] = {
18703 (char *) "self", NULL
18704 };
18705
18706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18708 if (SWIG_arg_fail(1)) SWIG_fail;
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 result = (int)((wxKeyEvent const *)arg1)->GetX();
18712
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 {
18717 resultobj = SWIG_From_int((int)(result));
18718 }
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18726 PyObject *resultobj;
18727 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18728 int result;
18729 PyObject * obj0 = 0 ;
18730 char *kwnames[] = {
18731 (char *) "self", NULL
18732 };
18733
18734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18736 if (SWIG_arg_fail(1)) SWIG_fail;
18737 {
18738 PyThreadState* __tstate = wxPyBeginAllowThreads();
18739 result = (int)((wxKeyEvent const *)arg1)->GetY();
18740
18741 wxPyEndAllowThreads(__tstate);
18742 if (PyErr_Occurred()) SWIG_fail;
18743 }
18744 {
18745 resultobj = SWIG_From_int((int)(result));
18746 }
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj;
18755 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18756 int arg2 ;
18757 PyObject * obj0 = 0 ;
18758 PyObject * obj1 = 0 ;
18759 char *kwnames[] = {
18760 (char *) "self",(char *) "m_x", NULL
18761 };
18762
18763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18765 if (SWIG_arg_fail(1)) SWIG_fail;
18766 {
18767 arg2 = (int)(SWIG_As_int(obj1));
18768 if (SWIG_arg_fail(2)) SWIG_fail;
18769 }
18770 if (arg1) (arg1)->m_x = arg2;
18771
18772 Py_INCREF(Py_None); resultobj = Py_None;
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18782 int result;
18783 PyObject * obj0 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "self", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 result = (int) ((arg1)->m_x);
18792
18793 {
18794 resultobj = SWIG_From_int((int)(result));
18795 }
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj;
18804 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18805 int arg2 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 char *kwnames[] = {
18809 (char *) "self",(char *) "m_y", NULL
18810 };
18811
18812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18814 if (SWIG_arg_fail(1)) SWIG_fail;
18815 {
18816 arg2 = (int)(SWIG_As_int(obj1));
18817 if (SWIG_arg_fail(2)) SWIG_fail;
18818 }
18819 if (arg1) (arg1)->m_y = arg2;
18820
18821 Py_INCREF(Py_None); resultobj = Py_None;
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18831 int result;
18832 PyObject * obj0 = 0 ;
18833 char *kwnames[] = {
18834 (char *) "self", NULL
18835 };
18836
18837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18839 if (SWIG_arg_fail(1)) SWIG_fail;
18840 result = (int) ((arg1)->m_y);
18841
18842 {
18843 resultobj = SWIG_From_int((int)(result));
18844 }
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj;
18853 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18854 long arg2 ;
18855 PyObject * obj0 = 0 ;
18856 PyObject * obj1 = 0 ;
18857 char *kwnames[] = {
18858 (char *) "self",(char *) "m_keyCode", NULL
18859 };
18860
18861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18863 if (SWIG_arg_fail(1)) SWIG_fail;
18864 {
18865 arg2 = (long)(SWIG_As_long(obj1));
18866 if (SWIG_arg_fail(2)) SWIG_fail;
18867 }
18868 if (arg1) (arg1)->m_keyCode = arg2;
18869
18870 Py_INCREF(Py_None); resultobj = Py_None;
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18878 PyObject *resultobj;
18879 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18880 long result;
18881 PyObject * obj0 = 0 ;
18882 char *kwnames[] = {
18883 (char *) "self", NULL
18884 };
18885
18886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18888 if (SWIG_arg_fail(1)) SWIG_fail;
18889 result = (long) ((arg1)->m_keyCode);
18890
18891 {
18892 resultobj = SWIG_From_long((long)(result));
18893 }
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj;
18902 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18903 bool arg2 ;
18904 PyObject * obj0 = 0 ;
18905 PyObject * obj1 = 0 ;
18906 char *kwnames[] = {
18907 (char *) "self",(char *) "m_controlDown", NULL
18908 };
18909
18910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18912 if (SWIG_arg_fail(1)) SWIG_fail;
18913 {
18914 arg2 = (bool)(SWIG_As_bool(obj1));
18915 if (SWIG_arg_fail(2)) SWIG_fail;
18916 }
18917 if (arg1) (arg1)->m_controlDown = arg2;
18918
18919 Py_INCREF(Py_None); resultobj = Py_None;
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18929 bool result;
18930 PyObject * obj0 = 0 ;
18931 char *kwnames[] = {
18932 (char *) "self", NULL
18933 };
18934
18935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18937 if (SWIG_arg_fail(1)) SWIG_fail;
18938 result = (bool) ((arg1)->m_controlDown);
18939
18940 {
18941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18942 }
18943 return resultobj;
18944 fail:
18945 return NULL;
18946 }
18947
18948
18949 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18950 PyObject *resultobj;
18951 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18952 bool arg2 ;
18953 PyObject * obj0 = 0 ;
18954 PyObject * obj1 = 0 ;
18955 char *kwnames[] = {
18956 (char *) "self",(char *) "m_shiftDown", NULL
18957 };
18958
18959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18961 if (SWIG_arg_fail(1)) SWIG_fail;
18962 {
18963 arg2 = (bool)(SWIG_As_bool(obj1));
18964 if (SWIG_arg_fail(2)) SWIG_fail;
18965 }
18966 if (arg1) (arg1)->m_shiftDown = arg2;
18967
18968 Py_INCREF(Py_None); resultobj = Py_None;
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18978 bool result;
18979 PyObject * obj0 = 0 ;
18980 char *kwnames[] = {
18981 (char *) "self", NULL
18982 };
18983
18984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18986 if (SWIG_arg_fail(1)) SWIG_fail;
18987 result = (bool) ((arg1)->m_shiftDown);
18988
18989 {
18990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18991 }
18992 return resultobj;
18993 fail:
18994 return NULL;
18995 }
18996
18997
18998 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18999 PyObject *resultobj;
19000 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19001 bool arg2 ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char *kwnames[] = {
19005 (char *) "self",(char *) "m_altDown", NULL
19006 };
19007
19008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19010 if (SWIG_arg_fail(1)) SWIG_fail;
19011 {
19012 arg2 = (bool)(SWIG_As_bool(obj1));
19013 if (SWIG_arg_fail(2)) SWIG_fail;
19014 }
19015 if (arg1) (arg1)->m_altDown = arg2;
19016
19017 Py_INCREF(Py_None); resultobj = Py_None;
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19025 PyObject *resultobj;
19026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19027 bool result;
19028 PyObject * obj0 = 0 ;
19029 char *kwnames[] = {
19030 (char *) "self", NULL
19031 };
19032
19033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19035 if (SWIG_arg_fail(1)) SWIG_fail;
19036 result = (bool) ((arg1)->m_altDown);
19037
19038 {
19039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19040 }
19041 return resultobj;
19042 fail:
19043 return NULL;
19044 }
19045
19046
19047 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19048 PyObject *resultobj;
19049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19050 bool arg2 ;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 char *kwnames[] = {
19054 (char *) "self",(char *) "m_metaDown", NULL
19055 };
19056
19057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19059 if (SWIG_arg_fail(1)) SWIG_fail;
19060 {
19061 arg2 = (bool)(SWIG_As_bool(obj1));
19062 if (SWIG_arg_fail(2)) SWIG_fail;
19063 }
19064 if (arg1) (arg1)->m_metaDown = arg2;
19065
19066 Py_INCREF(Py_None); resultobj = Py_None;
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19074 PyObject *resultobj;
19075 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19076 bool result;
19077 PyObject * obj0 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "self", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19084 if (SWIG_arg_fail(1)) SWIG_fail;
19085 result = (bool) ((arg1)->m_metaDown);
19086
19087 {
19088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19089 }
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj;
19098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19099 bool arg2 ;
19100 PyObject * obj0 = 0 ;
19101 PyObject * obj1 = 0 ;
19102 char *kwnames[] = {
19103 (char *) "self",(char *) "m_scanCode", NULL
19104 };
19105
19106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19108 if (SWIG_arg_fail(1)) SWIG_fail;
19109 {
19110 arg2 = (bool)(SWIG_As_bool(obj1));
19111 if (SWIG_arg_fail(2)) SWIG_fail;
19112 }
19113 if (arg1) (arg1)->m_scanCode = arg2;
19114
19115 Py_INCREF(Py_None); resultobj = Py_None;
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19125 bool result;
19126 PyObject * obj0 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "self", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19133 if (SWIG_arg_fail(1)) SWIG_fail;
19134 result = (bool) ((arg1)->m_scanCode);
19135
19136 {
19137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19138 }
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj;
19147 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19148 unsigned int arg2 ;
19149 PyObject * obj0 = 0 ;
19150 PyObject * obj1 = 0 ;
19151 char *kwnames[] = {
19152 (char *) "self",(char *) "m_rawCode", NULL
19153 };
19154
19155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19157 if (SWIG_arg_fail(1)) SWIG_fail;
19158 {
19159 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19160 if (SWIG_arg_fail(2)) SWIG_fail;
19161 }
19162 if (arg1) (arg1)->m_rawCode = arg2;
19163
19164 Py_INCREF(Py_None); resultobj = Py_None;
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj;
19173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19174 unsigned int result;
19175 PyObject * obj0 = 0 ;
19176 char *kwnames[] = {
19177 (char *) "self", NULL
19178 };
19179
19180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19182 if (SWIG_arg_fail(1)) SWIG_fail;
19183 result = (unsigned int) ((arg1)->m_rawCode);
19184
19185 {
19186 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19187 }
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19195 PyObject *resultobj;
19196 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19197 unsigned int arg2 ;
19198 PyObject * obj0 = 0 ;
19199 PyObject * obj1 = 0 ;
19200 char *kwnames[] = {
19201 (char *) "self",(char *) "m_rawFlags", NULL
19202 };
19203
19204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19206 if (SWIG_arg_fail(1)) SWIG_fail;
19207 {
19208 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19209 if (SWIG_arg_fail(2)) SWIG_fail;
19210 }
19211 if (arg1) (arg1)->m_rawFlags = arg2;
19212
19213 Py_INCREF(Py_None); resultobj = Py_None;
19214 return resultobj;
19215 fail:
19216 return NULL;
19217 }
19218
19219
19220 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19221 PyObject *resultobj;
19222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19223 unsigned int result;
19224 PyObject * obj0 = 0 ;
19225 char *kwnames[] = {
19226 (char *) "self", NULL
19227 };
19228
19229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19231 if (SWIG_arg_fail(1)) SWIG_fail;
19232 result = (unsigned int) ((arg1)->m_rawFlags);
19233
19234 {
19235 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19236 }
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19244 PyObject *obj;
19245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19246 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19247 Py_INCREF(obj);
19248 return Py_BuildValue((char *)"");
19249 }
19250 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 wxSize const &arg1_defvalue = wxDefaultSize ;
19253 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19254 int arg2 = (int) 0 ;
19255 wxSizeEvent *result;
19256 wxSize temp1 ;
19257 PyObject * obj0 = 0 ;
19258 PyObject * obj1 = 0 ;
19259 char *kwnames[] = {
19260 (char *) "sz",(char *) "winid", NULL
19261 };
19262
19263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19264 if (obj0) {
19265 {
19266 arg1 = &temp1;
19267 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19268 }
19269 }
19270 if (obj1) {
19271 {
19272 arg2 = (int)(SWIG_As_int(obj1));
19273 if (SWIG_arg_fail(2)) SWIG_fail;
19274 }
19275 }
19276 {
19277 PyThreadState* __tstate = wxPyBeginAllowThreads();
19278 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19279
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj;
19292 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19293 wxSize result;
19294 PyObject * obj0 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "self", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19301 if (SWIG_arg_fail(1)) SWIG_fail;
19302 {
19303 PyThreadState* __tstate = wxPyBeginAllowThreads();
19304 result = ((wxSizeEvent const *)arg1)->GetSize();
19305
19306 wxPyEndAllowThreads(__tstate);
19307 if (PyErr_Occurred()) SWIG_fail;
19308 }
19309 {
19310 wxSize * resultptr;
19311 resultptr = new wxSize((wxSize &)(result));
19312 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19313 }
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj;
19322 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19323 wxRect result;
19324 PyObject * obj0 = 0 ;
19325 char *kwnames[] = {
19326 (char *) "self", NULL
19327 };
19328
19329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19331 if (SWIG_arg_fail(1)) SWIG_fail;
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = ((wxSizeEvent const *)arg1)->GetRect();
19335
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 {
19340 wxRect * resultptr;
19341 resultptr = new wxRect((wxRect &)(result));
19342 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19343 }
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19351 PyObject *resultobj;
19352 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19353 wxRect arg2 ;
19354 PyObject * obj0 = 0 ;
19355 PyObject * obj1 = 0 ;
19356 char *kwnames[] = {
19357 (char *) "self",(char *) "rect", NULL
19358 };
19359
19360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19362 if (SWIG_arg_fail(1)) SWIG_fail;
19363 {
19364 wxRect * argp;
19365 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19366 if (SWIG_arg_fail(2)) SWIG_fail;
19367 if (argp == NULL) {
19368 SWIG_null_ref("wxRect");
19369 }
19370 if (SWIG_arg_fail(2)) SWIG_fail;
19371 arg2 = *argp;
19372 }
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 (arg1)->SetRect(arg2);
19376
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 Py_INCREF(Py_None); resultobj = Py_None;
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19388 PyObject *resultobj;
19389 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19390 wxSize arg2 ;
19391 PyObject * obj0 = 0 ;
19392 PyObject * obj1 = 0 ;
19393 char *kwnames[] = {
19394 (char *) "self",(char *) "size", NULL
19395 };
19396
19397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19399 if (SWIG_arg_fail(1)) SWIG_fail;
19400 {
19401 wxSize * argp;
19402 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19403 if (SWIG_arg_fail(2)) SWIG_fail;
19404 if (argp == NULL) {
19405 SWIG_null_ref("wxSize");
19406 }
19407 if (SWIG_arg_fail(2)) SWIG_fail;
19408 arg2 = *argp;
19409 }
19410 {
19411 PyThreadState* __tstate = wxPyBeginAllowThreads();
19412 wxSizeEvent_SetSize(arg1,arg2);
19413
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 Py_INCREF(Py_None); resultobj = Py_None;
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19425 PyObject *resultobj;
19426 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19427 wxSize *arg2 = (wxSize *) 0 ;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char *kwnames[] = {
19431 (char *) "self",(char *) "m_size", NULL
19432 };
19433
19434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19436 if (SWIG_arg_fail(1)) SWIG_fail;
19437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19438 if (SWIG_arg_fail(2)) SWIG_fail;
19439 if (arg1) (arg1)->m_size = *arg2;
19440
19441 Py_INCREF(Py_None); resultobj = Py_None;
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj;
19450 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19451 wxSize *result;
19452 PyObject * obj0 = 0 ;
19453 char *kwnames[] = {
19454 (char *) "self", NULL
19455 };
19456
19457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19459 if (SWIG_arg_fail(1)) SWIG_fail;
19460 result = (wxSize *)& ((arg1)->m_size);
19461
19462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19463 return resultobj;
19464 fail:
19465 return NULL;
19466 }
19467
19468
19469 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj;
19471 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19472 wxRect *arg2 = (wxRect *) 0 ;
19473 PyObject * obj0 = 0 ;
19474 PyObject * obj1 = 0 ;
19475 char *kwnames[] = {
19476 (char *) "self",(char *) "m_rect", NULL
19477 };
19478
19479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19481 if (SWIG_arg_fail(1)) SWIG_fail;
19482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19483 if (SWIG_arg_fail(2)) SWIG_fail;
19484 if (arg1) (arg1)->m_rect = *arg2;
19485
19486 Py_INCREF(Py_None); resultobj = Py_None;
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19494 PyObject *resultobj;
19495 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19496 wxRect *result;
19497 PyObject * obj0 = 0 ;
19498 char *kwnames[] = {
19499 (char *) "self", NULL
19500 };
19501
19502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19504 if (SWIG_arg_fail(1)) SWIG_fail;
19505 result = (wxRect *)& ((arg1)->m_rect);
19506
19507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19515 PyObject *obj;
19516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19517 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19518 Py_INCREF(obj);
19519 return Py_BuildValue((char *)"");
19520 }
19521 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19522 PyObject *resultobj;
19523 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19524 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19525 int arg2 = (int) 0 ;
19526 wxMoveEvent *result;
19527 wxPoint temp1 ;
19528 PyObject * obj0 = 0 ;
19529 PyObject * obj1 = 0 ;
19530 char *kwnames[] = {
19531 (char *) "pos",(char *) "winid", NULL
19532 };
19533
19534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19535 if (obj0) {
19536 {
19537 arg1 = &temp1;
19538 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19539 }
19540 }
19541 if (obj1) {
19542 {
19543 arg2 = (int)(SWIG_As_int(obj1));
19544 if (SWIG_arg_fail(2)) SWIG_fail;
19545 }
19546 }
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19550
19551 wxPyEndAllowThreads(__tstate);
19552 if (PyErr_Occurred()) SWIG_fail;
19553 }
19554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19555 return resultobj;
19556 fail:
19557 return NULL;
19558 }
19559
19560
19561 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj;
19563 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19564 wxPoint result;
19565 PyObject * obj0 = 0 ;
19566 char *kwnames[] = {
19567 (char *) "self", NULL
19568 };
19569
19570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19572 if (SWIG_arg_fail(1)) SWIG_fail;
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 result = ((wxMoveEvent const *)arg1)->GetPosition();
19576
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 {
19581 wxPoint * resultptr;
19582 resultptr = new wxPoint((wxPoint &)(result));
19583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19584 }
19585 return resultobj;
19586 fail:
19587 return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19592 PyObject *resultobj;
19593 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19594 wxRect result;
19595 PyObject * obj0 = 0 ;
19596 char *kwnames[] = {
19597 (char *) "self", NULL
19598 };
19599
19600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19602 if (SWIG_arg_fail(1)) SWIG_fail;
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = ((wxMoveEvent const *)arg1)->GetRect();
19606
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 {
19611 wxRect * resultptr;
19612 resultptr = new wxRect((wxRect &)(result));
19613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19614 }
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19622 PyObject *resultobj;
19623 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19624 wxRect *arg2 = 0 ;
19625 wxRect temp2 ;
19626 PyObject * obj0 = 0 ;
19627 PyObject * obj1 = 0 ;
19628 char *kwnames[] = {
19629 (char *) "self",(char *) "rect", NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19634 if (SWIG_arg_fail(1)) SWIG_fail;
19635 {
19636 arg2 = &temp2;
19637 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19638 }
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 (arg1)->SetRect((wxRect const &)*arg2);
19642
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 Py_INCREF(Py_None); resultobj = Py_None;
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj;
19655 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19656 wxPoint *arg2 = 0 ;
19657 wxPoint temp2 ;
19658 PyObject * obj0 = 0 ;
19659 PyObject * obj1 = 0 ;
19660 char *kwnames[] = {
19661 (char *) "self",(char *) "pos", NULL
19662 };
19663
19664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19666 if (SWIG_arg_fail(1)) SWIG_fail;
19667 {
19668 arg2 = &temp2;
19669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19670 }
19671 {
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 (arg1)->SetPosition((wxPoint const &)*arg2);
19674
19675 wxPyEndAllowThreads(__tstate);
19676 if (PyErr_Occurred()) SWIG_fail;
19677 }
19678 Py_INCREF(Py_None); resultobj = Py_None;
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19686 PyObject *obj;
19687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19688 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19689 Py_INCREF(obj);
19690 return Py_BuildValue((char *)"");
19691 }
19692 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19693 PyObject *resultobj;
19694 int arg1 = (int) 0 ;
19695 wxPaintEvent *result;
19696 PyObject * obj0 = 0 ;
19697 char *kwnames[] = {
19698 (char *) "Id", NULL
19699 };
19700
19701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19702 if (obj0) {
19703 {
19704 arg1 = (int)(SWIG_As_int(obj0));
19705 if (SWIG_arg_fail(1)) SWIG_fail;
19706 }
19707 }
19708 {
19709 PyThreadState* __tstate = wxPyBeginAllowThreads();
19710 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19711
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19716 return resultobj;
19717 fail:
19718 return NULL;
19719 }
19720
19721
19722 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19723 PyObject *obj;
19724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19725 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19726 Py_INCREF(obj);
19727 return Py_BuildValue((char *)"");
19728 }
19729 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19730 PyObject *resultobj;
19731 int arg1 = (int) 0 ;
19732 wxNcPaintEvent *result;
19733 PyObject * obj0 = 0 ;
19734 char *kwnames[] = {
19735 (char *) "winid", NULL
19736 };
19737
19738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19739 if (obj0) {
19740 {
19741 arg1 = (int)(SWIG_As_int(obj0));
19742 if (SWIG_arg_fail(1)) SWIG_fail;
19743 }
19744 }
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19760 PyObject *obj;
19761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19762 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19763 Py_INCREF(obj);
19764 return Py_BuildValue((char *)"");
19765 }
19766 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19767 PyObject *resultobj;
19768 int arg1 = (int) 0 ;
19769 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19770 wxEraseEvent *result;
19771 PyObject * obj0 = 0 ;
19772 PyObject * obj1 = 0 ;
19773 char *kwnames[] = {
19774 (char *) "Id",(char *) "dc", NULL
19775 };
19776
19777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19778 if (obj0) {
19779 {
19780 arg1 = (int)(SWIG_As_int(obj0));
19781 if (SWIG_arg_fail(1)) SWIG_fail;
19782 }
19783 }
19784 if (obj1) {
19785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(2)) SWIG_fail;
19787 }
19788 {
19789 PyThreadState* __tstate = wxPyBeginAllowThreads();
19790 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19791
19792 wxPyEndAllowThreads(__tstate);
19793 if (PyErr_Occurred()) SWIG_fail;
19794 }
19795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19796 return resultobj;
19797 fail:
19798 return NULL;
19799 }
19800
19801
19802 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19803 PyObject *resultobj;
19804 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19805 wxDC *result;
19806 PyObject * obj0 = 0 ;
19807 char *kwnames[] = {
19808 (char *) "self", NULL
19809 };
19810
19811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19813 if (SWIG_arg_fail(1)) SWIG_fail;
19814 {
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19817
19818 wxPyEndAllowThreads(__tstate);
19819 if (PyErr_Occurred()) SWIG_fail;
19820 }
19821 {
19822 resultobj = wxPyMake_wxObject(result, 0);
19823 }
19824 return resultobj;
19825 fail:
19826 return NULL;
19827 }
19828
19829
19830 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19831 PyObject *obj;
19832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19833 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19834 Py_INCREF(obj);
19835 return Py_BuildValue((char *)"");
19836 }
19837 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19838 PyObject *resultobj;
19839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19840 int arg2 = (int) 0 ;
19841 wxFocusEvent *result;
19842 PyObject * obj0 = 0 ;
19843 PyObject * obj1 = 0 ;
19844 char *kwnames[] = {
19845 (char *) "type",(char *) "winid", NULL
19846 };
19847
19848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19849 if (obj0) {
19850 {
19851 arg1 = (wxEventType)(SWIG_As_int(obj0));
19852 if (SWIG_arg_fail(1)) SWIG_fail;
19853 }
19854 }
19855 if (obj1) {
19856 {
19857 arg2 = (int)(SWIG_As_int(obj1));
19858 if (SWIG_arg_fail(2)) SWIG_fail;
19859 }
19860 }
19861 {
19862 PyThreadState* __tstate = wxPyBeginAllowThreads();
19863 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19869 return resultobj;
19870 fail:
19871 return NULL;
19872 }
19873
19874
19875 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19876 PyObject *resultobj;
19877 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19878 wxWindow *result;
19879 PyObject * obj0 = 0 ;
19880 char *kwnames[] = {
19881 (char *) "self", NULL
19882 };
19883
19884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19886 if (SWIG_arg_fail(1)) SWIG_fail;
19887 {
19888 PyThreadState* __tstate = wxPyBeginAllowThreads();
19889 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19890
19891 wxPyEndAllowThreads(__tstate);
19892 if (PyErr_Occurred()) SWIG_fail;
19893 }
19894 {
19895 resultobj = wxPyMake_wxObject(result, 0);
19896 }
19897 return resultobj;
19898 fail:
19899 return NULL;
19900 }
19901
19902
19903 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19904 PyObject *resultobj;
19905 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19906 wxWindow *arg2 = (wxWindow *) 0 ;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 char *kwnames[] = {
19910 (char *) "self",(char *) "win", NULL
19911 };
19912
19913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19915 if (SWIG_arg_fail(1)) SWIG_fail;
19916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19917 if (SWIG_arg_fail(2)) SWIG_fail;
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 (arg1)->SetWindow(arg2);
19921
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 Py_INCREF(Py_None); resultobj = Py_None;
19926 return resultobj;
19927 fail:
19928 return NULL;
19929 }
19930
19931
19932 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19933 PyObject *obj;
19934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19935 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19936 Py_INCREF(obj);
19937 return Py_BuildValue((char *)"");
19938 }
19939 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19940 PyObject *resultobj;
19941 wxWindow *arg1 = (wxWindow *) NULL ;
19942 wxChildFocusEvent *result;
19943 PyObject * obj0 = 0 ;
19944 char *kwnames[] = {
19945 (char *) "win", NULL
19946 };
19947
19948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19949 if (obj0) {
19950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19951 if (SWIG_arg_fail(1)) SWIG_fail;
19952 }
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19956
19957 wxPyEndAllowThreads(__tstate);
19958 if (PyErr_Occurred()) SWIG_fail;
19959 }
19960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19961 return resultobj;
19962 fail:
19963 return NULL;
19964 }
19965
19966
19967 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19968 PyObject *resultobj;
19969 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19970 wxWindow *result;
19971 PyObject * obj0 = 0 ;
19972 char *kwnames[] = {
19973 (char *) "self", NULL
19974 };
19975
19976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19978 if (SWIG_arg_fail(1)) SWIG_fail;
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19982
19983 wxPyEndAllowThreads(__tstate);
19984 if (PyErr_Occurred()) SWIG_fail;
19985 }
19986 {
19987 resultobj = wxPyMake_wxObject(result, 0);
19988 }
19989 return resultobj;
19990 fail:
19991 return NULL;
19992 }
19993
19994
19995 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19996 PyObject *obj;
19997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19998 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19999 Py_INCREF(obj);
20000 return Py_BuildValue((char *)"");
20001 }
20002 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20003 PyObject *resultobj;
20004 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20005 bool arg2 = (bool) true ;
20006 int arg3 = (int) 0 ;
20007 wxActivateEvent *result;
20008 PyObject * obj0 = 0 ;
20009 PyObject * obj1 = 0 ;
20010 PyObject * obj2 = 0 ;
20011 char *kwnames[] = {
20012 (char *) "type",(char *) "active",(char *) "Id", NULL
20013 };
20014
20015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20016 if (obj0) {
20017 {
20018 arg1 = (wxEventType)(SWIG_As_int(obj0));
20019 if (SWIG_arg_fail(1)) SWIG_fail;
20020 }
20021 }
20022 if (obj1) {
20023 {
20024 arg2 = (bool)(SWIG_As_bool(obj1));
20025 if (SWIG_arg_fail(2)) SWIG_fail;
20026 }
20027 }
20028 if (obj2) {
20029 {
20030 arg3 = (int)(SWIG_As_int(obj2));
20031 if (SWIG_arg_fail(3)) SWIG_fail;
20032 }
20033 }
20034 {
20035 PyThreadState* __tstate = wxPyBeginAllowThreads();
20036 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20037
20038 wxPyEndAllowThreads(__tstate);
20039 if (PyErr_Occurred()) SWIG_fail;
20040 }
20041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20042 return resultobj;
20043 fail:
20044 return NULL;
20045 }
20046
20047
20048 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20049 PyObject *resultobj;
20050 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20051 bool result;
20052 PyObject * obj0 = 0 ;
20053 char *kwnames[] = {
20054 (char *) "self", NULL
20055 };
20056
20057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20059 if (SWIG_arg_fail(1)) SWIG_fail;
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20063
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 {
20068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20069 }
20070 return resultobj;
20071 fail:
20072 return NULL;
20073 }
20074
20075
20076 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20077 PyObject *obj;
20078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20079 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20080 Py_INCREF(obj);
20081 return Py_BuildValue((char *)"");
20082 }
20083 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20084 PyObject *resultobj;
20085 int arg1 = (int) 0 ;
20086 wxInitDialogEvent *result;
20087 PyObject * obj0 = 0 ;
20088 char *kwnames[] = {
20089 (char *) "Id", NULL
20090 };
20091
20092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20093 if (obj0) {
20094 {
20095 arg1 = (int)(SWIG_As_int(obj0));
20096 if (SWIG_arg_fail(1)) SWIG_fail;
20097 }
20098 }
20099 {
20100 PyThreadState* __tstate = wxPyBeginAllowThreads();
20101 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20102
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20114 PyObject *obj;
20115 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20116 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20117 Py_INCREF(obj);
20118 return Py_BuildValue((char *)"");
20119 }
20120 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20121 PyObject *resultobj;
20122 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20123 int arg2 = (int) 0 ;
20124 wxMenu *arg3 = (wxMenu *) NULL ;
20125 wxMenuEvent *result;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 PyObject * obj2 = 0 ;
20129 char *kwnames[] = {
20130 (char *) "type",(char *) "winid",(char *) "menu", NULL
20131 };
20132
20133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20134 if (obj0) {
20135 {
20136 arg1 = (wxEventType)(SWIG_As_int(obj0));
20137 if (SWIG_arg_fail(1)) SWIG_fail;
20138 }
20139 }
20140 if (obj1) {
20141 {
20142 arg2 = (int)(SWIG_As_int(obj1));
20143 if (SWIG_arg_fail(2)) SWIG_fail;
20144 }
20145 }
20146 if (obj2) {
20147 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20148 if (SWIG_arg_fail(3)) SWIG_fail;
20149 }
20150 {
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20153
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20165 PyObject *resultobj;
20166 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20167 int result;
20168 PyObject * obj0 = 0 ;
20169 char *kwnames[] = {
20170 (char *) "self", NULL
20171 };
20172
20173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20175 if (SWIG_arg_fail(1)) SWIG_fail;
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20179
20180 wxPyEndAllowThreads(__tstate);
20181 if (PyErr_Occurred()) SWIG_fail;
20182 }
20183 {
20184 resultobj = SWIG_From_int((int)(result));
20185 }
20186 return resultobj;
20187 fail:
20188 return NULL;
20189 }
20190
20191
20192 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20193 PyObject *resultobj;
20194 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20195 bool result;
20196 PyObject * obj0 = 0 ;
20197 char *kwnames[] = {
20198 (char *) "self", NULL
20199 };
20200
20201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20203 if (SWIG_arg_fail(1)) SWIG_fail;
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20207
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 {
20212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20213 }
20214 return resultobj;
20215 fail:
20216 return NULL;
20217 }
20218
20219
20220 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20221 PyObject *resultobj;
20222 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20223 wxMenu *result;
20224 PyObject * obj0 = 0 ;
20225 char *kwnames[] = {
20226 (char *) "self", NULL
20227 };
20228
20229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20231 if (SWIG_arg_fail(1)) SWIG_fail;
20232 {
20233 PyThreadState* __tstate = wxPyBeginAllowThreads();
20234 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20235
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 {
20240 resultobj = wxPyMake_wxObject(result, 0);
20241 }
20242 return resultobj;
20243 fail:
20244 return NULL;
20245 }
20246
20247
20248 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20249 PyObject *obj;
20250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20251 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20252 Py_INCREF(obj);
20253 return Py_BuildValue((char *)"");
20254 }
20255 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20256 PyObject *resultobj;
20257 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20258 int arg2 = (int) 0 ;
20259 wxCloseEvent *result;
20260 PyObject * obj0 = 0 ;
20261 PyObject * obj1 = 0 ;
20262 char *kwnames[] = {
20263 (char *) "type",(char *) "winid", NULL
20264 };
20265
20266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20267 if (obj0) {
20268 {
20269 arg1 = (wxEventType)(SWIG_As_int(obj0));
20270 if (SWIG_arg_fail(1)) SWIG_fail;
20271 }
20272 }
20273 if (obj1) {
20274 {
20275 arg2 = (int)(SWIG_As_int(obj1));
20276 if (SWIG_arg_fail(2)) SWIG_fail;
20277 }
20278 }
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20282
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20287 return resultobj;
20288 fail:
20289 return NULL;
20290 }
20291
20292
20293 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20294 PyObject *resultobj;
20295 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20296 bool arg2 ;
20297 PyObject * obj0 = 0 ;
20298 PyObject * obj1 = 0 ;
20299 char *kwnames[] = {
20300 (char *) "self",(char *) "logOff", NULL
20301 };
20302
20303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20305 if (SWIG_arg_fail(1)) SWIG_fail;
20306 {
20307 arg2 = (bool)(SWIG_As_bool(obj1));
20308 if (SWIG_arg_fail(2)) SWIG_fail;
20309 }
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 (arg1)->SetLoggingOff(arg2);
20313
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 Py_INCREF(Py_None); resultobj = Py_None;
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20325 PyObject *resultobj;
20326 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20327 bool result;
20328 PyObject * obj0 = 0 ;
20329 char *kwnames[] = {
20330 (char *) "self", NULL
20331 };
20332
20333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20335 if (SWIG_arg_fail(1)) SWIG_fail;
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20339
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 {
20344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20345 }
20346 return resultobj;
20347 fail:
20348 return NULL;
20349 }
20350
20351
20352 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20353 PyObject *resultobj;
20354 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20355 bool arg2 = (bool) true ;
20356 PyObject * obj0 = 0 ;
20357 PyObject * obj1 = 0 ;
20358 char *kwnames[] = {
20359 (char *) "self",(char *) "veto", NULL
20360 };
20361
20362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20364 if (SWIG_arg_fail(1)) SWIG_fail;
20365 if (obj1) {
20366 {
20367 arg2 = (bool)(SWIG_As_bool(obj1));
20368 if (SWIG_arg_fail(2)) SWIG_fail;
20369 }
20370 }
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 (arg1)->Veto(arg2);
20374
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 Py_INCREF(Py_None); resultobj = Py_None;
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20386 PyObject *resultobj;
20387 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20388 bool arg2 ;
20389 PyObject * obj0 = 0 ;
20390 PyObject * obj1 = 0 ;
20391 char *kwnames[] = {
20392 (char *) "self",(char *) "canVeto", NULL
20393 };
20394
20395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 {
20399 arg2 = (bool)(SWIG_As_bool(obj1));
20400 if (SWIG_arg_fail(2)) SWIG_fail;
20401 }
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 (arg1)->SetCanVeto(arg2);
20405
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 Py_INCREF(Py_None); resultobj = Py_None;
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20417 PyObject *resultobj;
20418 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20419 bool result;
20420 PyObject * obj0 = 0 ;
20421 char *kwnames[] = {
20422 (char *) "self", NULL
20423 };
20424
20425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20427 if (SWIG_arg_fail(1)) SWIG_fail;
20428 {
20429 PyThreadState* __tstate = wxPyBeginAllowThreads();
20430 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20431
20432 wxPyEndAllowThreads(__tstate);
20433 if (PyErr_Occurred()) SWIG_fail;
20434 }
20435 {
20436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20437 }
20438 return resultobj;
20439 fail:
20440 return NULL;
20441 }
20442
20443
20444 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20445 PyObject *resultobj;
20446 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20447 bool result;
20448 PyObject * obj0 = 0 ;
20449 char *kwnames[] = {
20450 (char *) "self", NULL
20451 };
20452
20453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20455 if (SWIG_arg_fail(1)) SWIG_fail;
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 {
20464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20465 }
20466 return resultobj;
20467 fail:
20468 return NULL;
20469 }
20470
20471
20472 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20473 PyObject *obj;
20474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20475 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20476 Py_INCREF(obj);
20477 return Py_BuildValue((char *)"");
20478 }
20479 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20480 PyObject *resultobj;
20481 int arg1 = (int) 0 ;
20482 bool arg2 = (bool) false ;
20483 wxShowEvent *result;
20484 PyObject * obj0 = 0 ;
20485 PyObject * obj1 = 0 ;
20486 char *kwnames[] = {
20487 (char *) "winid",(char *) "show", NULL
20488 };
20489
20490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20491 if (obj0) {
20492 {
20493 arg1 = (int)(SWIG_As_int(obj0));
20494 if (SWIG_arg_fail(1)) SWIG_fail;
20495 }
20496 }
20497 if (obj1) {
20498 {
20499 arg2 = (bool)(SWIG_As_bool(obj1));
20500 if (SWIG_arg_fail(2)) SWIG_fail;
20501 }
20502 }
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20506
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20518 PyObject *resultobj;
20519 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20520 bool arg2 ;
20521 PyObject * obj0 = 0 ;
20522 PyObject * obj1 = 0 ;
20523 char *kwnames[] = {
20524 (char *) "self",(char *) "show", NULL
20525 };
20526
20527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20529 if (SWIG_arg_fail(1)) SWIG_fail;
20530 {
20531 arg2 = (bool)(SWIG_As_bool(obj1));
20532 if (SWIG_arg_fail(2)) SWIG_fail;
20533 }
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 (arg1)->SetShow(arg2);
20537
20538 wxPyEndAllowThreads(__tstate);
20539 if (PyErr_Occurred()) SWIG_fail;
20540 }
20541 Py_INCREF(Py_None); resultobj = Py_None;
20542 return resultobj;
20543 fail:
20544 return NULL;
20545 }
20546
20547
20548 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20549 PyObject *resultobj;
20550 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20551 bool result;
20552 PyObject * obj0 = 0 ;
20553 char *kwnames[] = {
20554 (char *) "self", NULL
20555 };
20556
20557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20563
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20569 }
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20577 PyObject *obj;
20578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20579 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20580 Py_INCREF(obj);
20581 return Py_BuildValue((char *)"");
20582 }
20583 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20584 PyObject *resultobj;
20585 int arg1 = (int) 0 ;
20586 bool arg2 = (bool) true ;
20587 wxIconizeEvent *result;
20588 PyObject * obj0 = 0 ;
20589 PyObject * obj1 = 0 ;
20590 char *kwnames[] = {
20591 (char *) "id",(char *) "iconized", NULL
20592 };
20593
20594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20595 if (obj0) {
20596 {
20597 arg1 = (int)(SWIG_As_int(obj0));
20598 if (SWIG_arg_fail(1)) SWIG_fail;
20599 }
20600 }
20601 if (obj1) {
20602 {
20603 arg2 = (bool)(SWIG_As_bool(obj1));
20604 if (SWIG_arg_fail(2)) SWIG_fail;
20605 }
20606 }
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj;
20623 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20624 bool result;
20625 PyObject * obj0 = 0 ;
20626 char *kwnames[] = {
20627 (char *) "self", NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20632 if (SWIG_arg_fail(1)) SWIG_fail;
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (bool)(arg1)->Iconized();
20636
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 {
20641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20642 }
20643 return resultobj;
20644 fail:
20645 return NULL;
20646 }
20647
20648
20649 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20650 PyObject *obj;
20651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20652 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20653 Py_INCREF(obj);
20654 return Py_BuildValue((char *)"");
20655 }
20656 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj;
20658 int arg1 = (int) 0 ;
20659 wxMaximizeEvent *result;
20660 PyObject * obj0 = 0 ;
20661 char *kwnames[] = {
20662 (char *) "id", NULL
20663 };
20664
20665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20666 if (obj0) {
20667 {
20668 arg1 = (int)(SWIG_As_int(obj0));
20669 if (SWIG_arg_fail(1)) SWIG_fail;
20670 }
20671 }
20672 {
20673 PyThreadState* __tstate = wxPyBeginAllowThreads();
20674 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20675
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20687 PyObject *obj;
20688 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20689 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20690 Py_INCREF(obj);
20691 return Py_BuildValue((char *)"");
20692 }
20693 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj;
20695 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20696 wxPoint result;
20697 PyObject * obj0 = 0 ;
20698 char *kwnames[] = {
20699 (char *) "self", NULL
20700 };
20701
20702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20704 if (SWIG_arg_fail(1)) SWIG_fail;
20705 {
20706 PyThreadState* __tstate = wxPyBeginAllowThreads();
20707 result = (arg1)->GetPosition();
20708
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 {
20713 wxPoint * resultptr;
20714 resultptr = new wxPoint((wxPoint &)(result));
20715 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20716 }
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20724 PyObject *resultobj;
20725 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20726 int result;
20727 PyObject * obj0 = 0 ;
20728 char *kwnames[] = {
20729 (char *) "self", NULL
20730 };
20731
20732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20734 if (SWIG_arg_fail(1)) SWIG_fail;
20735 {
20736 PyThreadState* __tstate = wxPyBeginAllowThreads();
20737 result = (int)(arg1)->GetNumberOfFiles();
20738
20739 wxPyEndAllowThreads(__tstate);
20740 if (PyErr_Occurred()) SWIG_fail;
20741 }
20742 {
20743 resultobj = SWIG_From_int((int)(result));
20744 }
20745 return resultobj;
20746 fail:
20747 return NULL;
20748 }
20749
20750
20751 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20752 PyObject *resultobj;
20753 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20754 PyObject *result;
20755 PyObject * obj0 = 0 ;
20756 char *kwnames[] = {
20757 (char *) "self", NULL
20758 };
20759
20760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20762 if (SWIG_arg_fail(1)) SWIG_fail;
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20766
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 resultobj = result;
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20778 PyObject *obj;
20779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20780 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20781 Py_INCREF(obj);
20782 return Py_BuildValue((char *)"");
20783 }
20784 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20785 PyObject *resultobj;
20786 int arg1 = (int) 0 ;
20787 wxUpdateUIEvent *result;
20788 PyObject * obj0 = 0 ;
20789 char *kwnames[] = {
20790 (char *) "commandId", NULL
20791 };
20792
20793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20794 if (obj0) {
20795 {
20796 arg1 = (int)(SWIG_As_int(obj0));
20797 if (SWIG_arg_fail(1)) SWIG_fail;
20798 }
20799 }
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20803
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20808 return resultobj;
20809 fail:
20810 return NULL;
20811 }
20812
20813
20814 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20815 PyObject *resultobj;
20816 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20817 bool result;
20818 PyObject * obj0 = 0 ;
20819 char *kwnames[] = {
20820 (char *) "self", NULL
20821 };
20822
20823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(1)) SWIG_fail;
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 {
20834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20835 }
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj;
20844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20845 bool result;
20846 PyObject * obj0 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "self", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20857
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 {
20862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20863 }
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20871 PyObject *resultobj;
20872 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20873 wxString result;
20874 PyObject * obj0 = 0 ;
20875 char *kwnames[] = {
20876 (char *) "self", NULL
20877 };
20878
20879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20881 if (SWIG_arg_fail(1)) SWIG_fail;
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20885
20886 wxPyEndAllowThreads(__tstate);
20887 if (PyErr_Occurred()) SWIG_fail;
20888 }
20889 {
20890 #if wxUSE_UNICODE
20891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20892 #else
20893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20894 #endif
20895 }
20896 return resultobj;
20897 fail:
20898 return NULL;
20899 }
20900
20901
20902 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20903 PyObject *resultobj;
20904 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20905 bool result;
20906 PyObject * obj0 = 0 ;
20907 char *kwnames[] = {
20908 (char *) "self", NULL
20909 };
20910
20911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20913 if (SWIG_arg_fail(1)) SWIG_fail;
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20917
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 {
20922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20923 }
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20931 PyObject *resultobj;
20932 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20933 bool result;
20934 PyObject * obj0 = 0 ;
20935 char *kwnames[] = {
20936 (char *) "self", NULL
20937 };
20938
20939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20941 if (SWIG_arg_fail(1)) SWIG_fail;
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 {
20950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20951 }
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20959 PyObject *resultobj;
20960 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20961 bool result;
20962 PyObject * obj0 = 0 ;
20963 char *kwnames[] = {
20964 (char *) "self", NULL
20965 };
20966
20967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20969 if (SWIG_arg_fail(1)) SWIG_fail;
20970 {
20971 PyThreadState* __tstate = wxPyBeginAllowThreads();
20972 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20973
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj;
20988 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20989 bool arg2 ;
20990 PyObject * obj0 = 0 ;
20991 PyObject * obj1 = 0 ;
20992 char *kwnames[] = {
20993 (char *) "self",(char *) "check", NULL
20994 };
20995
20996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20998 if (SWIG_arg_fail(1)) SWIG_fail;
20999 {
21000 arg2 = (bool)(SWIG_As_bool(obj1));
21001 if (SWIG_arg_fail(2)) SWIG_fail;
21002 }
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 (arg1)->Check(arg2);
21006
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 Py_INCREF(Py_None); resultobj = Py_None;
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj;
21019 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21020 bool arg2 ;
21021 PyObject * obj0 = 0 ;
21022 PyObject * obj1 = 0 ;
21023 char *kwnames[] = {
21024 (char *) "self",(char *) "enable", NULL
21025 };
21026
21027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21029 if (SWIG_arg_fail(1)) SWIG_fail;
21030 {
21031 arg2 = (bool)(SWIG_As_bool(obj1));
21032 if (SWIG_arg_fail(2)) SWIG_fail;
21033 }
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 (arg1)->Enable(arg2);
21037
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 Py_INCREF(Py_None); resultobj = Py_None;
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21049 PyObject *resultobj;
21050 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21051 wxString *arg2 = 0 ;
21052 bool temp2 = false ;
21053 PyObject * obj0 = 0 ;
21054 PyObject * obj1 = 0 ;
21055 char *kwnames[] = {
21056 (char *) "self",(char *) "text", NULL
21057 };
21058
21059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21061 if (SWIG_arg_fail(1)) SWIG_fail;
21062 {
21063 arg2 = wxString_in_helper(obj1);
21064 if (arg2 == NULL) SWIG_fail;
21065 temp2 = true;
21066 }
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 (arg1)->SetText((wxString const &)*arg2);
21070
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 Py_INCREF(Py_None); resultobj = Py_None;
21075 {
21076 if (temp2)
21077 delete arg2;
21078 }
21079 return resultobj;
21080 fail:
21081 {
21082 if (temp2)
21083 delete arg2;
21084 }
21085 return NULL;
21086 }
21087
21088
21089 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj;
21091 long arg1 ;
21092 PyObject * obj0 = 0 ;
21093 char *kwnames[] = {
21094 (char *) "updateInterval", NULL
21095 };
21096
21097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21098 {
21099 arg1 = (long)(SWIG_As_long(obj0));
21100 if (SWIG_arg_fail(1)) SWIG_fail;
21101 }
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 wxUpdateUIEvent::SetUpdateInterval(arg1);
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 Py_INCREF(Py_None); resultobj = Py_None;
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21117 PyObject *resultobj;
21118 long result;
21119 char *kwnames[] = {
21120 NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21127
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 {
21132 resultobj = SWIG_From_long((long)(result));
21133 }
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21141 PyObject *resultobj;
21142 wxWindow *arg1 = (wxWindow *) 0 ;
21143 bool result;
21144 PyObject * obj0 = 0 ;
21145 char *kwnames[] = {
21146 (char *) "win", NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21151 if (SWIG_arg_fail(1)) SWIG_fail;
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21155
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 {
21160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21161 }
21162 return resultobj;
21163 fail:
21164 return NULL;
21165 }
21166
21167
21168 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21169 PyObject *resultobj;
21170 char *kwnames[] = {
21171 NULL
21172 };
21173
21174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21175 {
21176 PyThreadState* __tstate = wxPyBeginAllowThreads();
21177 wxUpdateUIEvent::ResetUpdateTime();
21178
21179 wxPyEndAllowThreads(__tstate);
21180 if (PyErr_Occurred()) SWIG_fail;
21181 }
21182 Py_INCREF(Py_None); resultobj = Py_None;
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj;
21191 wxUpdateUIMode arg1 ;
21192 PyObject * obj0 = 0 ;
21193 char *kwnames[] = {
21194 (char *) "mode", NULL
21195 };
21196
21197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21198 {
21199 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21200 if (SWIG_arg_fail(1)) SWIG_fail;
21201 }
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 Py_INCREF(Py_None); resultobj = Py_None;
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj;
21218 wxUpdateUIMode result;
21219 char *kwnames[] = {
21220 NULL
21221 };
21222
21223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21227
21228 wxPyEndAllowThreads(__tstate);
21229 if (PyErr_Occurred()) SWIG_fail;
21230 }
21231 resultobj = SWIG_From_int((result));
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21239 PyObject *obj;
21240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21241 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21242 Py_INCREF(obj);
21243 return Py_BuildValue((char *)"");
21244 }
21245 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21246 PyObject *resultobj;
21247 wxSysColourChangedEvent *result;
21248 char *kwnames[] = {
21249 NULL
21250 };
21251
21252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21256
21257 wxPyEndAllowThreads(__tstate);
21258 if (PyErr_Occurred()) SWIG_fail;
21259 }
21260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21268 PyObject *obj;
21269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21270 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21271 Py_INCREF(obj);
21272 return Py_BuildValue((char *)"");
21273 }
21274 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21275 PyObject *resultobj;
21276 int arg1 = (int) 0 ;
21277 wxWindow *arg2 = (wxWindow *) NULL ;
21278 wxMouseCaptureChangedEvent *result;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char *kwnames[] = {
21282 (char *) "winid",(char *) "gainedCapture", NULL
21283 };
21284
21285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21286 if (obj0) {
21287 {
21288 arg1 = (int)(SWIG_As_int(obj0));
21289 if (SWIG_arg_fail(1)) SWIG_fail;
21290 }
21291 }
21292 if (obj1) {
21293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21294 if (SWIG_arg_fail(2)) SWIG_fail;
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21299
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj;
21312 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21313 wxWindow *result;
21314 PyObject * obj0 = 0 ;
21315 char *kwnames[] = {
21316 (char *) "self", NULL
21317 };
21318
21319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21321 if (SWIG_arg_fail(1)) SWIG_fail;
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21325
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 {
21330 resultobj = wxPyMake_wxObject(result, 0);
21331 }
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21339 PyObject *obj;
21340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21341 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21342 Py_INCREF(obj);
21343 return Py_BuildValue((char *)"");
21344 }
21345 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21346 PyObject *resultobj;
21347 wxDisplayChangedEvent *result;
21348 char *kwnames[] = {
21349 NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21356
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21368 PyObject *obj;
21369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21370 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21371 Py_INCREF(obj);
21372 return Py_BuildValue((char *)"");
21373 }
21374 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21375 PyObject *resultobj;
21376 int arg1 = (int) 0 ;
21377 wxPaletteChangedEvent *result;
21378 PyObject * obj0 = 0 ;
21379 char *kwnames[] = {
21380 (char *) "id", NULL
21381 };
21382
21383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21384 if (obj0) {
21385 {
21386 arg1 = (int)(SWIG_As_int(obj0));
21387 if (SWIG_arg_fail(1)) SWIG_fail;
21388 }
21389 }
21390 {
21391 PyThreadState* __tstate = wxPyBeginAllowThreads();
21392 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21393
21394 wxPyEndAllowThreads(__tstate);
21395 if (PyErr_Occurred()) SWIG_fail;
21396 }
21397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21398 return resultobj;
21399 fail:
21400 return NULL;
21401 }
21402
21403
21404 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21405 PyObject *resultobj;
21406 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21407 wxWindow *arg2 = (wxWindow *) 0 ;
21408 PyObject * obj0 = 0 ;
21409 PyObject * obj1 = 0 ;
21410 char *kwnames[] = {
21411 (char *) "self",(char *) "win", NULL
21412 };
21413
21414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21416 if (SWIG_arg_fail(1)) SWIG_fail;
21417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21418 if (SWIG_arg_fail(2)) SWIG_fail;
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 (arg1)->SetChangedWindow(arg2);
21422
21423 wxPyEndAllowThreads(__tstate);
21424 if (PyErr_Occurred()) SWIG_fail;
21425 }
21426 Py_INCREF(Py_None); resultobj = Py_None;
21427 return resultobj;
21428 fail:
21429 return NULL;
21430 }
21431
21432
21433 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21434 PyObject *resultobj;
21435 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21436 wxWindow *result;
21437 PyObject * obj0 = 0 ;
21438 char *kwnames[] = {
21439 (char *) "self", NULL
21440 };
21441
21442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21444 if (SWIG_arg_fail(1)) SWIG_fail;
21445 {
21446 PyThreadState* __tstate = wxPyBeginAllowThreads();
21447 result = (wxWindow *)(arg1)->GetChangedWindow();
21448
21449 wxPyEndAllowThreads(__tstate);
21450 if (PyErr_Occurred()) SWIG_fail;
21451 }
21452 {
21453 resultobj = wxPyMake_wxObject(result, 0);
21454 }
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21462 PyObject *obj;
21463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21464 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21465 Py_INCREF(obj);
21466 return Py_BuildValue((char *)"");
21467 }
21468 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21469 PyObject *resultobj;
21470 int arg1 = (int) 0 ;
21471 wxQueryNewPaletteEvent *result;
21472 PyObject * obj0 = 0 ;
21473 char *kwnames[] = {
21474 (char *) "winid", NULL
21475 };
21476
21477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21478 if (obj0) {
21479 {
21480 arg1 = (int)(SWIG_As_int(obj0));
21481 if (SWIG_arg_fail(1)) SWIG_fail;
21482 }
21483 }
21484 {
21485 PyThreadState* __tstate = wxPyBeginAllowThreads();
21486 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21487
21488 wxPyEndAllowThreads(__tstate);
21489 if (PyErr_Occurred()) SWIG_fail;
21490 }
21491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21499 PyObject *resultobj;
21500 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21501 bool arg2 ;
21502 PyObject * obj0 = 0 ;
21503 PyObject * obj1 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self",(char *) "realized", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 {
21512 arg2 = (bool)(SWIG_As_bool(obj1));
21513 if (SWIG_arg_fail(2)) SWIG_fail;
21514 }
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 (arg1)->SetPaletteRealized(arg2);
21518
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 Py_INCREF(Py_None); resultobj = Py_None;
21523 return resultobj;
21524 fail:
21525 return NULL;
21526 }
21527
21528
21529 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21532 bool result;
21533 PyObject * obj0 = 0 ;
21534 char *kwnames[] = {
21535 (char *) "self", NULL
21536 };
21537
21538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21540 if (SWIG_arg_fail(1)) SWIG_fail;
21541 {
21542 PyThreadState* __tstate = wxPyBeginAllowThreads();
21543 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21544
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 {
21549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21550 }
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21558 PyObject *obj;
21559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21560 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21561 Py_INCREF(obj);
21562 return Py_BuildValue((char *)"");
21563 }
21564 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21565 PyObject *resultobj;
21566 wxNavigationKeyEvent *result;
21567 char *kwnames[] = {
21568 NULL
21569 };
21570
21571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21572 {
21573 PyThreadState* __tstate = wxPyBeginAllowThreads();
21574 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21575
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21580 return resultobj;
21581 fail:
21582 return NULL;
21583 }
21584
21585
21586 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21587 PyObject *resultobj;
21588 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21589 bool result;
21590 PyObject * obj0 = 0 ;
21591 char *kwnames[] = {
21592 (char *) "self", NULL
21593 };
21594
21595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21597 if (SWIG_arg_fail(1)) SWIG_fail;
21598 {
21599 PyThreadState* __tstate = wxPyBeginAllowThreads();
21600 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21601
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 {
21606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21607 }
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21615 PyObject *resultobj;
21616 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21617 bool arg2 ;
21618 PyObject * obj0 = 0 ;
21619 PyObject * obj1 = 0 ;
21620 char *kwnames[] = {
21621 (char *) "self",(char *) "forward", NULL
21622 };
21623
21624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21626 if (SWIG_arg_fail(1)) SWIG_fail;
21627 {
21628 arg2 = (bool)(SWIG_As_bool(obj1));
21629 if (SWIG_arg_fail(2)) SWIG_fail;
21630 }
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 (arg1)->SetDirection(arg2);
21634
21635 wxPyEndAllowThreads(__tstate);
21636 if (PyErr_Occurred()) SWIG_fail;
21637 }
21638 Py_INCREF(Py_None); resultobj = Py_None;
21639 return resultobj;
21640 fail:
21641 return NULL;
21642 }
21643
21644
21645 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21646 PyObject *resultobj;
21647 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21648 bool result;
21649 PyObject * obj0 = 0 ;
21650 char *kwnames[] = {
21651 (char *) "self", NULL
21652 };
21653
21654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21656 if (SWIG_arg_fail(1)) SWIG_fail;
21657 {
21658 PyThreadState* __tstate = wxPyBeginAllowThreads();
21659 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21660
21661 wxPyEndAllowThreads(__tstate);
21662 if (PyErr_Occurred()) SWIG_fail;
21663 }
21664 {
21665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21666 }
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21674 PyObject *resultobj;
21675 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21676 bool arg2 ;
21677 PyObject * obj0 = 0 ;
21678 PyObject * obj1 = 0 ;
21679 char *kwnames[] = {
21680 (char *) "self",(char *) "ischange", NULL
21681 };
21682
21683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21685 if (SWIG_arg_fail(1)) SWIG_fail;
21686 {
21687 arg2 = (bool)(SWIG_As_bool(obj1));
21688 if (SWIG_arg_fail(2)) SWIG_fail;
21689 }
21690 {
21691 PyThreadState* __tstate = wxPyBeginAllowThreads();
21692 (arg1)->SetWindowChange(arg2);
21693
21694 wxPyEndAllowThreads(__tstate);
21695 if (PyErr_Occurred()) SWIG_fail;
21696 }
21697 Py_INCREF(Py_None); resultobj = Py_None;
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj;
21706 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21707 bool result;
21708 PyObject * obj0 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(1)) SWIG_fail;
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 {
21724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21725 }
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21733 PyObject *resultobj;
21734 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21735 bool arg2 ;
21736 PyObject * obj0 = 0 ;
21737 PyObject * obj1 = 0 ;
21738 char *kwnames[] = {
21739 (char *) "self",(char *) "bIs", NULL
21740 };
21741
21742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21744 if (SWIG_arg_fail(1)) SWIG_fail;
21745 {
21746 arg2 = (bool)(SWIG_As_bool(obj1));
21747 if (SWIG_arg_fail(2)) SWIG_fail;
21748 }
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 (arg1)->SetFromTab(arg2);
21752
21753 wxPyEndAllowThreads(__tstate);
21754 if (PyErr_Occurred()) SWIG_fail;
21755 }
21756 Py_INCREF(Py_None); resultobj = Py_None;
21757 return resultobj;
21758 fail:
21759 return NULL;
21760 }
21761
21762
21763 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21764 PyObject *resultobj;
21765 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21766 long arg2 ;
21767 PyObject * obj0 = 0 ;
21768 PyObject * obj1 = 0 ;
21769 char *kwnames[] = {
21770 (char *) "self",(char *) "flags", NULL
21771 };
21772
21773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21775 if (SWIG_arg_fail(1)) SWIG_fail;
21776 {
21777 arg2 = (long)(SWIG_As_long(obj1));
21778 if (SWIG_arg_fail(2)) SWIG_fail;
21779 }
21780 {
21781 PyThreadState* __tstate = wxPyBeginAllowThreads();
21782 (arg1)->SetFlags(arg2);
21783
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 Py_INCREF(Py_None); resultobj = Py_None;
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21795 PyObject *resultobj;
21796 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21797 wxWindow *result;
21798 PyObject * obj0 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "self", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(1)) SWIG_fail;
21806 {
21807 PyThreadState* __tstate = wxPyBeginAllowThreads();
21808 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21809
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 {
21814 resultobj = wxPyMake_wxObject(result, 0);
21815 }
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj;
21824 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21825 wxWindow *arg2 = (wxWindow *) 0 ;
21826 PyObject * obj0 = 0 ;
21827 PyObject * obj1 = 0 ;
21828 char *kwnames[] = {
21829 (char *) "self",(char *) "win", NULL
21830 };
21831
21832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21834 if (SWIG_arg_fail(1)) SWIG_fail;
21835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21836 if (SWIG_arg_fail(2)) SWIG_fail;
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 (arg1)->SetCurrentFocus(arg2);
21840
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 Py_INCREF(Py_None); resultobj = Py_None;
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21852 PyObject *obj;
21853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21854 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21855 Py_INCREF(obj);
21856 return Py_BuildValue((char *)"");
21857 }
21858 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21859 PyObject *resultobj;
21860 wxWindow *arg1 = (wxWindow *) NULL ;
21861 wxWindowCreateEvent *result;
21862 PyObject * obj0 = 0 ;
21863 char *kwnames[] = {
21864 (char *) "win", NULL
21865 };
21866
21867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21868 if (obj0) {
21869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21870 if (SWIG_arg_fail(1)) SWIG_fail;
21871 }
21872 {
21873 PyThreadState* __tstate = wxPyBeginAllowThreads();
21874 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21875
21876 wxPyEndAllowThreads(__tstate);
21877 if (PyErr_Occurred()) SWIG_fail;
21878 }
21879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21887 PyObject *resultobj;
21888 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21889 wxWindow *result;
21890 PyObject * obj0 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21901
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 {
21906 resultobj = wxPyMake_wxObject(result, 0);
21907 }
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21915 PyObject *obj;
21916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21917 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21918 Py_INCREF(obj);
21919 return Py_BuildValue((char *)"");
21920 }
21921 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21922 PyObject *resultobj;
21923 wxWindow *arg1 = (wxWindow *) NULL ;
21924 wxWindowDestroyEvent *result;
21925 PyObject * obj0 = 0 ;
21926 char *kwnames[] = {
21927 (char *) "win", NULL
21928 };
21929
21930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21931 if (obj0) {
21932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21933 if (SWIG_arg_fail(1)) SWIG_fail;
21934 }
21935 {
21936 PyThreadState* __tstate = wxPyBeginAllowThreads();
21937 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21938
21939 wxPyEndAllowThreads(__tstate);
21940 if (PyErr_Occurred()) SWIG_fail;
21941 }
21942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21943 return resultobj;
21944 fail:
21945 return NULL;
21946 }
21947
21948
21949 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj;
21951 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21952 wxWindow *result;
21953 PyObject * obj0 = 0 ;
21954 char *kwnames[] = {
21955 (char *) "self", NULL
21956 };
21957
21958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21960 if (SWIG_arg_fail(1)) SWIG_fail;
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21964
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 {
21969 resultobj = wxPyMake_wxObject(result, 0);
21970 }
21971 return resultobj;
21972 fail:
21973 return NULL;
21974 }
21975
21976
21977 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21978 PyObject *obj;
21979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21980 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21981 Py_INCREF(obj);
21982 return Py_BuildValue((char *)"");
21983 }
21984 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21985 PyObject *resultobj;
21986 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21987 int arg2 = (int) 0 ;
21988 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21989 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21990 wxContextMenuEvent *result;
21991 wxPoint temp3 ;
21992 PyObject * obj0 = 0 ;
21993 PyObject * obj1 = 0 ;
21994 PyObject * obj2 = 0 ;
21995 char *kwnames[] = {
21996 (char *) "type",(char *) "winid",(char *) "pt", NULL
21997 };
21998
21999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22000 if (obj0) {
22001 {
22002 arg1 = (wxEventType)(SWIG_As_int(obj0));
22003 if (SWIG_arg_fail(1)) SWIG_fail;
22004 }
22005 }
22006 if (obj1) {
22007 {
22008 arg2 = (int)(SWIG_As_int(obj1));
22009 if (SWIG_arg_fail(2)) SWIG_fail;
22010 }
22011 }
22012 if (obj2) {
22013 {
22014 arg3 = &temp3;
22015 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22016 }
22017 }
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22021
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj;
22034 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22035 wxPoint *result;
22036 PyObject * obj0 = 0 ;
22037 char *kwnames[] = {
22038 (char *) "self", NULL
22039 };
22040
22041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22043 if (SWIG_arg_fail(1)) SWIG_fail;
22044 {
22045 PyThreadState* __tstate = wxPyBeginAllowThreads();
22046 {
22047 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22048 result = (wxPoint *) &_result_ref;
22049 }
22050
22051 wxPyEndAllowThreads(__tstate);
22052 if (PyErr_Occurred()) SWIG_fail;
22053 }
22054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22055 return resultobj;
22056 fail:
22057 return NULL;
22058 }
22059
22060
22061 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj;
22063 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22064 wxPoint *arg2 = 0 ;
22065 wxPoint temp2 ;
22066 PyObject * obj0 = 0 ;
22067 PyObject * obj1 = 0 ;
22068 char *kwnames[] = {
22069 (char *) "self",(char *) "pos", NULL
22070 };
22071
22072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22074 if (SWIG_arg_fail(1)) SWIG_fail;
22075 {
22076 arg2 = &temp2;
22077 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22078 }
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 (arg1)->SetPosition((wxPoint const &)*arg2);
22082
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 Py_INCREF(Py_None); resultobj = Py_None;
22087 return resultobj;
22088 fail:
22089 return NULL;
22090 }
22091
22092
22093 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22094 PyObject *obj;
22095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22096 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22097 Py_INCREF(obj);
22098 return Py_BuildValue((char *)"");
22099 }
22100 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22101 PyObject *resultobj;
22102 wxIdleEvent *result;
22103 char *kwnames[] = {
22104 NULL
22105 };
22106
22107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 result = (wxIdleEvent *)new wxIdleEvent();
22111
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj;
22124 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22125 bool arg2 = (bool) true ;
22126 PyObject * obj0 = 0 ;
22127 PyObject * obj1 = 0 ;
22128 char *kwnames[] = {
22129 (char *) "self",(char *) "needMore", NULL
22130 };
22131
22132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22134 if (SWIG_arg_fail(1)) SWIG_fail;
22135 if (obj1) {
22136 {
22137 arg2 = (bool)(SWIG_As_bool(obj1));
22138 if (SWIG_arg_fail(2)) SWIG_fail;
22139 }
22140 }
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 (arg1)->RequestMore(arg2);
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 Py_INCREF(Py_None); resultobj = Py_None;
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22156 PyObject *resultobj;
22157 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22158 bool result;
22159 PyObject * obj0 = 0 ;
22160 char *kwnames[] = {
22161 (char *) "self", NULL
22162 };
22163
22164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22166 if (SWIG_arg_fail(1)) SWIG_fail;
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22170
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 {
22175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22176 }
22177 return resultobj;
22178 fail:
22179 return NULL;
22180 }
22181
22182
22183 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22184 PyObject *resultobj;
22185 wxIdleMode arg1 ;
22186 PyObject * obj0 = 0 ;
22187 char *kwnames[] = {
22188 (char *) "mode", NULL
22189 };
22190
22191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22192 {
22193 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22194 if (SWIG_arg_fail(1)) SWIG_fail;
22195 }
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 wxIdleEvent::SetMode((wxIdleMode )arg1);
22199
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 Py_INCREF(Py_None); resultobj = Py_None;
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj;
22212 wxIdleMode result;
22213 char *kwnames[] = {
22214 NULL
22215 };
22216
22217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22218 {
22219 PyThreadState* __tstate = wxPyBeginAllowThreads();
22220 result = (wxIdleMode)wxIdleEvent::GetMode();
22221
22222 wxPyEndAllowThreads(__tstate);
22223 if (PyErr_Occurred()) SWIG_fail;
22224 }
22225 resultobj = SWIG_From_int((result));
22226 return resultobj;
22227 fail:
22228 return NULL;
22229 }
22230
22231
22232 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22233 PyObject *resultobj;
22234 wxWindow *arg1 = (wxWindow *) 0 ;
22235 bool result;
22236 PyObject * obj0 = 0 ;
22237 char *kwnames[] = {
22238 (char *) "win", NULL
22239 };
22240
22241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22243 if (SWIG_arg_fail(1)) SWIG_fail;
22244 {
22245 PyThreadState* __tstate = wxPyBeginAllowThreads();
22246 result = (bool)wxIdleEvent::CanSend(arg1);
22247
22248 wxPyEndAllowThreads(__tstate);
22249 if (PyErr_Occurred()) SWIG_fail;
22250 }
22251 {
22252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22253 }
22254 return resultobj;
22255 fail:
22256 return NULL;
22257 }
22258
22259
22260 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22261 PyObject *obj;
22262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22263 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22264 Py_INCREF(obj);
22265 return Py_BuildValue((char *)"");
22266 }
22267 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22268 PyObject *resultobj;
22269 int arg1 = (int) 0 ;
22270 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22271 wxPyEvent *result;
22272 PyObject * obj0 = 0 ;
22273 PyObject * obj1 = 0 ;
22274 char *kwnames[] = {
22275 (char *) "winid",(char *) "commandType", NULL
22276 };
22277
22278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22279 if (obj0) {
22280 {
22281 arg1 = (int)(SWIG_As_int(obj0));
22282 if (SWIG_arg_fail(1)) SWIG_fail;
22283 }
22284 }
22285 if (obj1) {
22286 {
22287 arg2 = (wxEventType)(SWIG_As_int(obj1));
22288 if (SWIG_arg_fail(2)) SWIG_fail;
22289 }
22290 }
22291 {
22292 PyThreadState* __tstate = wxPyBeginAllowThreads();
22293 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22294
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22306 PyObject *resultobj;
22307 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22308 PyObject * obj0 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "self", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 delete arg1;
22319
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 Py_INCREF(Py_None); resultobj = Py_None;
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22331 PyObject *resultobj;
22332 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22333 PyObject *arg2 = (PyObject *) 0 ;
22334 PyObject * obj0 = 0 ;
22335 PyObject * obj1 = 0 ;
22336 char *kwnames[] = {
22337 (char *) "self",(char *) "self", NULL
22338 };
22339
22340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22342 if (SWIG_arg_fail(1)) SWIG_fail;
22343 arg2 = obj1;
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 (arg1)->SetSelf(arg2);
22347
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 Py_INCREF(Py_None); resultobj = Py_None;
22352 return resultobj;
22353 fail:
22354 return NULL;
22355 }
22356
22357
22358 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22359 PyObject *resultobj;
22360 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22361 PyObject *result;
22362 PyObject * obj0 = 0 ;
22363 char *kwnames[] = {
22364 (char *) "self", NULL
22365 };
22366
22367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22369 if (SWIG_arg_fail(1)) SWIG_fail;
22370 {
22371 PyThreadState* __tstate = wxPyBeginAllowThreads();
22372 result = (PyObject *)(arg1)->GetSelf();
22373
22374 wxPyEndAllowThreads(__tstate);
22375 if (PyErr_Occurred()) SWIG_fail;
22376 }
22377 resultobj = result;
22378 return resultobj;
22379 fail:
22380 return NULL;
22381 }
22382
22383
22384 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22385 PyObject *obj;
22386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22387 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22388 Py_INCREF(obj);
22389 return Py_BuildValue((char *)"");
22390 }
22391 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj;
22393 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22394 int arg2 = (int) 0 ;
22395 wxPyCommandEvent *result;
22396 PyObject * obj0 = 0 ;
22397 PyObject * obj1 = 0 ;
22398 char *kwnames[] = {
22399 (char *) "commandType",(char *) "id", NULL
22400 };
22401
22402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22403 if (obj0) {
22404 {
22405 arg1 = (wxEventType)(SWIG_As_int(obj0));
22406 if (SWIG_arg_fail(1)) SWIG_fail;
22407 }
22408 }
22409 if (obj1) {
22410 {
22411 arg2 = (int)(SWIG_As_int(obj1));
22412 if (SWIG_arg_fail(2)) SWIG_fail;
22413 }
22414 }
22415 {
22416 PyThreadState* __tstate = wxPyBeginAllowThreads();
22417 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22418
22419 wxPyEndAllowThreads(__tstate);
22420 if (PyErr_Occurred()) SWIG_fail;
22421 }
22422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22423 return resultobj;
22424 fail:
22425 return NULL;
22426 }
22427
22428
22429 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22430 PyObject *resultobj;
22431 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22432 PyObject * obj0 = 0 ;
22433 char *kwnames[] = {
22434 (char *) "self", NULL
22435 };
22436
22437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22439 if (SWIG_arg_fail(1)) SWIG_fail;
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 delete arg1;
22443
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 Py_INCREF(Py_None); resultobj = Py_None;
22448 return resultobj;
22449 fail:
22450 return NULL;
22451 }
22452
22453
22454 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22455 PyObject *resultobj;
22456 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22457 PyObject *arg2 = (PyObject *) 0 ;
22458 PyObject * obj0 = 0 ;
22459 PyObject * obj1 = 0 ;
22460 char *kwnames[] = {
22461 (char *) "self",(char *) "self", NULL
22462 };
22463
22464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22466 if (SWIG_arg_fail(1)) SWIG_fail;
22467 arg2 = obj1;
22468 {
22469 PyThreadState* __tstate = wxPyBeginAllowThreads();
22470 (arg1)->SetSelf(arg2);
22471
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 Py_INCREF(Py_None); resultobj = Py_None;
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22483 PyObject *resultobj;
22484 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22485 PyObject *result;
22486 PyObject * obj0 = 0 ;
22487 char *kwnames[] = {
22488 (char *) "self", NULL
22489 };
22490
22491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22493 if (SWIG_arg_fail(1)) SWIG_fail;
22494 {
22495 PyThreadState* __tstate = wxPyBeginAllowThreads();
22496 result = (PyObject *)(arg1)->GetSelf();
22497
22498 wxPyEndAllowThreads(__tstate);
22499 if (PyErr_Occurred()) SWIG_fail;
22500 }
22501 resultobj = result;
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22509 PyObject *obj;
22510 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22511 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22512 Py_INCREF(obj);
22513 return Py_BuildValue((char *)"");
22514 }
22515 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22516 PyObject *resultobj;
22517 wxWindow *arg1 = (wxWindow *) 0 ;
22518 wxDateTime *arg2 = 0 ;
22519 wxEventType arg3 ;
22520 wxDateEvent *result;
22521 PyObject * obj0 = 0 ;
22522 PyObject * obj1 = 0 ;
22523 PyObject * obj2 = 0 ;
22524 char *kwnames[] = {
22525 (char *) "win",(char *) "dt",(char *) "type", NULL
22526 };
22527
22528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22530 if (SWIG_arg_fail(1)) SWIG_fail;
22531 {
22532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22533 if (SWIG_arg_fail(2)) SWIG_fail;
22534 if (arg2 == NULL) {
22535 SWIG_null_ref("wxDateTime");
22536 }
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 }
22539 {
22540 arg3 = (wxEventType)(SWIG_As_int(obj2));
22541 if (SWIG_arg_fail(3)) SWIG_fail;
22542 }
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22546
22547 wxPyEndAllowThreads(__tstate);
22548 if (PyErr_Occurred()) SWIG_fail;
22549 }
22550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22551 return resultobj;
22552 fail:
22553 return NULL;
22554 }
22555
22556
22557 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22558 PyObject *resultobj;
22559 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22560 wxDateTime *result;
22561 PyObject * obj0 = 0 ;
22562 char *kwnames[] = {
22563 (char *) "self", NULL
22564 };
22565
22566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22568 if (SWIG_arg_fail(1)) SWIG_fail;
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 {
22572 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22573 result = (wxDateTime *) &_result_ref;
22574 }
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22580 return resultobj;
22581 fail:
22582 return NULL;
22583 }
22584
22585
22586 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22587 PyObject *resultobj;
22588 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22589 wxDateTime *arg2 = 0 ;
22590 PyObject * obj0 = 0 ;
22591 PyObject * obj1 = 0 ;
22592 char *kwnames[] = {
22593 (char *) "self",(char *) "date", NULL
22594 };
22595
22596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22598 if (SWIG_arg_fail(1)) SWIG_fail;
22599 {
22600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22601 if (SWIG_arg_fail(2)) SWIG_fail;
22602 if (arg2 == NULL) {
22603 SWIG_null_ref("wxDateTime");
22604 }
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 }
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 (arg1)->SetDate((wxDateTime const &)*arg2);
22610
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 Py_INCREF(Py_None); resultobj = Py_None;
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22622 PyObject *obj;
22623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22624 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22625 Py_INCREF(obj);
22626 return Py_BuildValue((char *)"");
22627 }
22628 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22629 PyObject *resultobj;
22630 wxPyApp *result;
22631 char *kwnames[] = {
22632 NULL
22633 };
22634
22635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22636 {
22637 PyThreadState* __tstate = wxPyBeginAllowThreads();
22638 result = (wxPyApp *)new_wxPyApp();
22639
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22651 PyObject *resultobj;
22652 wxPyApp *arg1 = (wxPyApp *) 0 ;
22653 PyObject * obj0 = 0 ;
22654 char *kwnames[] = {
22655 (char *) "self", NULL
22656 };
22657
22658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22660 if (SWIG_arg_fail(1)) SWIG_fail;
22661 {
22662 PyThreadState* __tstate = wxPyBeginAllowThreads();
22663 delete arg1;
22664
22665 wxPyEndAllowThreads(__tstate);
22666 if (PyErr_Occurred()) SWIG_fail;
22667 }
22668 Py_INCREF(Py_None); resultobj = Py_None;
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22676 PyObject *resultobj;
22677 wxPyApp *arg1 = (wxPyApp *) 0 ;
22678 PyObject *arg2 = (PyObject *) 0 ;
22679 PyObject *arg3 = (PyObject *) 0 ;
22680 bool arg4 ;
22681 PyObject * obj0 = 0 ;
22682 PyObject * obj1 = 0 ;
22683 PyObject * obj2 = 0 ;
22684 PyObject * obj3 = 0 ;
22685 char *kwnames[] = {
22686 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22687 };
22688
22689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22691 if (SWIG_arg_fail(1)) SWIG_fail;
22692 arg2 = obj1;
22693 arg3 = obj2;
22694 {
22695 arg4 = (bool)(SWIG_As_bool(obj3));
22696 if (SWIG_arg_fail(4)) SWIG_fail;
22697 }
22698 {
22699 PyThreadState* __tstate = wxPyBeginAllowThreads();
22700 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22701
22702 wxPyEndAllowThreads(__tstate);
22703 if (PyErr_Occurred()) SWIG_fail;
22704 }
22705 Py_INCREF(Py_None); resultobj = Py_None;
22706 return resultobj;
22707 fail:
22708 return NULL;
22709 }
22710
22711
22712 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22713 PyObject *resultobj;
22714 wxPyApp *arg1 = (wxPyApp *) 0 ;
22715 wxString result;
22716 PyObject * obj0 = 0 ;
22717 char *kwnames[] = {
22718 (char *) "self", NULL
22719 };
22720
22721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22723 if (SWIG_arg_fail(1)) SWIG_fail;
22724 {
22725 PyThreadState* __tstate = wxPyBeginAllowThreads();
22726 result = ((wxPyApp const *)arg1)->GetAppName();
22727
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 {
22732 #if wxUSE_UNICODE
22733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22734 #else
22735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22736 #endif
22737 }
22738 return resultobj;
22739 fail:
22740 return NULL;
22741 }
22742
22743
22744 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22745 PyObject *resultobj;
22746 wxPyApp *arg1 = (wxPyApp *) 0 ;
22747 wxString *arg2 = 0 ;
22748 bool temp2 = false ;
22749 PyObject * obj0 = 0 ;
22750 PyObject * obj1 = 0 ;
22751 char *kwnames[] = {
22752 (char *) "self",(char *) "name", NULL
22753 };
22754
22755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22757 if (SWIG_arg_fail(1)) SWIG_fail;
22758 {
22759 arg2 = wxString_in_helper(obj1);
22760 if (arg2 == NULL) SWIG_fail;
22761 temp2 = true;
22762 }
22763 {
22764 PyThreadState* __tstate = wxPyBeginAllowThreads();
22765 (arg1)->SetAppName((wxString const &)*arg2);
22766
22767 wxPyEndAllowThreads(__tstate);
22768 if (PyErr_Occurred()) SWIG_fail;
22769 }
22770 Py_INCREF(Py_None); resultobj = Py_None;
22771 {
22772 if (temp2)
22773 delete arg2;
22774 }
22775 return resultobj;
22776 fail:
22777 {
22778 if (temp2)
22779 delete arg2;
22780 }
22781 return NULL;
22782 }
22783
22784
22785 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22786 PyObject *resultobj;
22787 wxPyApp *arg1 = (wxPyApp *) 0 ;
22788 wxString result;
22789 PyObject * obj0 = 0 ;
22790 char *kwnames[] = {
22791 (char *) "self", NULL
22792 };
22793
22794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22796 if (SWIG_arg_fail(1)) SWIG_fail;
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 result = ((wxPyApp const *)arg1)->GetClassName();
22800
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 {
22805 #if wxUSE_UNICODE
22806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22807 #else
22808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22809 #endif
22810 }
22811 return resultobj;
22812 fail:
22813 return NULL;
22814 }
22815
22816
22817 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22818 PyObject *resultobj;
22819 wxPyApp *arg1 = (wxPyApp *) 0 ;
22820 wxString *arg2 = 0 ;
22821 bool temp2 = false ;
22822 PyObject * obj0 = 0 ;
22823 PyObject * obj1 = 0 ;
22824 char *kwnames[] = {
22825 (char *) "self",(char *) "name", NULL
22826 };
22827
22828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22830 if (SWIG_arg_fail(1)) SWIG_fail;
22831 {
22832 arg2 = wxString_in_helper(obj1);
22833 if (arg2 == NULL) SWIG_fail;
22834 temp2 = true;
22835 }
22836 {
22837 PyThreadState* __tstate = wxPyBeginAllowThreads();
22838 (arg1)->SetClassName((wxString const &)*arg2);
22839
22840 wxPyEndAllowThreads(__tstate);
22841 if (PyErr_Occurred()) SWIG_fail;
22842 }
22843 Py_INCREF(Py_None); resultobj = Py_None;
22844 {
22845 if (temp2)
22846 delete arg2;
22847 }
22848 return resultobj;
22849 fail:
22850 {
22851 if (temp2)
22852 delete arg2;
22853 }
22854 return NULL;
22855 }
22856
22857
22858 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22859 PyObject *resultobj;
22860 wxPyApp *arg1 = (wxPyApp *) 0 ;
22861 wxString *result;
22862 PyObject * obj0 = 0 ;
22863 char *kwnames[] = {
22864 (char *) "self", NULL
22865 };
22866
22867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22869 if (SWIG_arg_fail(1)) SWIG_fail;
22870 {
22871 PyThreadState* __tstate = wxPyBeginAllowThreads();
22872 {
22873 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22874 result = (wxString *) &_result_ref;
22875 }
22876
22877 wxPyEndAllowThreads(__tstate);
22878 if (PyErr_Occurred()) SWIG_fail;
22879 }
22880 {
22881 #if wxUSE_UNICODE
22882 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22883 #else
22884 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22885 #endif
22886 }
22887 return resultobj;
22888 fail:
22889 return NULL;
22890 }
22891
22892
22893 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22894 PyObject *resultobj;
22895 wxPyApp *arg1 = (wxPyApp *) 0 ;
22896 wxString *arg2 = 0 ;
22897 bool temp2 = false ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 char *kwnames[] = {
22901 (char *) "self",(char *) "name", NULL
22902 };
22903
22904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22906 if (SWIG_arg_fail(1)) SWIG_fail;
22907 {
22908 arg2 = wxString_in_helper(obj1);
22909 if (arg2 == NULL) SWIG_fail;
22910 temp2 = true;
22911 }
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 (arg1)->SetVendorName((wxString const &)*arg2);
22915
22916 wxPyEndAllowThreads(__tstate);
22917 if (PyErr_Occurred()) SWIG_fail;
22918 }
22919 Py_INCREF(Py_None); resultobj = Py_None;
22920 {
22921 if (temp2)
22922 delete arg2;
22923 }
22924 return resultobj;
22925 fail:
22926 {
22927 if (temp2)
22928 delete arg2;
22929 }
22930 return NULL;
22931 }
22932
22933
22934 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22935 PyObject *resultobj;
22936 wxPyApp *arg1 = (wxPyApp *) 0 ;
22937 wxAppTraits *result;
22938 PyObject * obj0 = 0 ;
22939 char *kwnames[] = {
22940 (char *) "self", NULL
22941 };
22942
22943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22945 if (SWIG_arg_fail(1)) SWIG_fail;
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = (wxAppTraits *)(arg1)->GetTraits();
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22961 PyObject *resultobj;
22962 wxPyApp *arg1 = (wxPyApp *) 0 ;
22963 PyObject * obj0 = 0 ;
22964 char *kwnames[] = {
22965 (char *) "self", NULL
22966 };
22967
22968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22970 if (SWIG_arg_fail(1)) SWIG_fail;
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 (arg1)->ProcessPendingEvents();
22974
22975 wxPyEndAllowThreads(__tstate);
22976 if (PyErr_Occurred()) SWIG_fail;
22977 }
22978 Py_INCREF(Py_None); resultobj = Py_None;
22979 return resultobj;
22980 fail:
22981 return NULL;
22982 }
22983
22984
22985 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22986 PyObject *resultobj;
22987 wxPyApp *arg1 = (wxPyApp *) 0 ;
22988 bool arg2 = (bool) false ;
22989 bool result;
22990 PyObject * obj0 = 0 ;
22991 PyObject * obj1 = 0 ;
22992 char *kwnames[] = {
22993 (char *) "self",(char *) "onlyIfNeeded", NULL
22994 };
22995
22996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22998 if (SWIG_arg_fail(1)) SWIG_fail;
22999 if (obj1) {
23000 {
23001 arg2 = (bool)(SWIG_As_bool(obj1));
23002 if (SWIG_arg_fail(2)) SWIG_fail;
23003 }
23004 }
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (bool)(arg1)->Yield(arg2);
23008
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 {
23013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23014 }
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23022 PyObject *resultobj;
23023 wxPyApp *arg1 = (wxPyApp *) 0 ;
23024 PyObject * obj0 = 0 ;
23025 char *kwnames[] = {
23026 (char *) "self", NULL
23027 };
23028
23029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23031 if (SWIG_arg_fail(1)) SWIG_fail;
23032 {
23033 PyThreadState* __tstate = wxPyBeginAllowThreads();
23034 (arg1)->WakeUpIdle();
23035
23036 wxPyEndAllowThreads(__tstate);
23037 if (PyErr_Occurred()) SWIG_fail;
23038 }
23039 Py_INCREF(Py_None); resultobj = Py_None;
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23047 PyObject *resultobj;
23048 bool result;
23049 char *kwnames[] = {
23050 NULL
23051 };
23052
23053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23054 {
23055 PyThreadState* __tstate = wxPyBeginAllowThreads();
23056 result = (bool)wxPyApp::IsMainLoopRunning();
23057
23058 wxPyEndAllowThreads(__tstate);
23059 if (PyErr_Occurred()) SWIG_fail;
23060 }
23061 {
23062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23063 }
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23071 PyObject *resultobj;
23072 wxPyApp *arg1 = (wxPyApp *) 0 ;
23073 int result;
23074 PyObject * obj0 = 0 ;
23075 char *kwnames[] = {
23076 (char *) "self", NULL
23077 };
23078
23079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23081 if (SWIG_arg_fail(1)) SWIG_fail;
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (int)(arg1)->MainLoop();
23085
23086 wxPyEndAllowThreads(__tstate);
23087 if (PyErr_Occurred()) SWIG_fail;
23088 }
23089 {
23090 resultobj = SWIG_From_int((int)(result));
23091 }
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj;
23100 wxPyApp *arg1 = (wxPyApp *) 0 ;
23101 PyObject * obj0 = 0 ;
23102 char *kwnames[] = {
23103 (char *) "self", NULL
23104 };
23105
23106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23108 if (SWIG_arg_fail(1)) SWIG_fail;
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 (arg1)->Exit();
23112
23113 wxPyEndAllowThreads(__tstate);
23114 if (PyErr_Occurred()) SWIG_fail;
23115 }
23116 Py_INCREF(Py_None); resultobj = Py_None;
23117 return resultobj;
23118 fail:
23119 return NULL;
23120 }
23121
23122
23123 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23124 PyObject *resultobj;
23125 wxPyApp *arg1 = (wxPyApp *) 0 ;
23126 PyObject * obj0 = 0 ;
23127 char *kwnames[] = {
23128 (char *) "self", NULL
23129 };
23130
23131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23133 if (SWIG_arg_fail(1)) SWIG_fail;
23134 {
23135 PyThreadState* __tstate = wxPyBeginAllowThreads();
23136 (arg1)->ExitMainLoop();
23137
23138 wxPyEndAllowThreads(__tstate);
23139 if (PyErr_Occurred()) SWIG_fail;
23140 }
23141 Py_INCREF(Py_None); resultobj = Py_None;
23142 return resultobj;
23143 fail:
23144 return NULL;
23145 }
23146
23147
23148 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23149 PyObject *resultobj;
23150 wxPyApp *arg1 = (wxPyApp *) 0 ;
23151 bool result;
23152 PyObject * obj0 = 0 ;
23153 char *kwnames[] = {
23154 (char *) "self", NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23159 if (SWIG_arg_fail(1)) SWIG_fail;
23160 {
23161 PyThreadState* __tstate = wxPyBeginAllowThreads();
23162 result = (bool)(arg1)->Pending();
23163
23164 wxPyEndAllowThreads(__tstate);
23165 if (PyErr_Occurred()) SWIG_fail;
23166 }
23167 {
23168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23169 }
23170 return resultobj;
23171 fail:
23172 return NULL;
23173 }
23174
23175
23176 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23177 PyObject *resultobj;
23178 wxPyApp *arg1 = (wxPyApp *) 0 ;
23179 bool result;
23180 PyObject * obj0 = 0 ;
23181 char *kwnames[] = {
23182 (char *) "self", NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(1)) SWIG_fail;
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = (bool)(arg1)->Dispatch();
23191
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 {
23196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23197 }
23198 return resultobj;
23199 fail:
23200 return NULL;
23201 }
23202
23203
23204 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23205 PyObject *resultobj;
23206 wxPyApp *arg1 = (wxPyApp *) 0 ;
23207 bool result;
23208 PyObject * obj0 = 0 ;
23209 char *kwnames[] = {
23210 (char *) "self", NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23215 if (SWIG_arg_fail(1)) SWIG_fail;
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (bool)(arg1)->ProcessIdle();
23219
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 {
23224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23225 }
23226 return resultobj;
23227 fail:
23228 return NULL;
23229 }
23230
23231
23232 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23233 PyObject *resultobj;
23234 wxPyApp *arg1 = (wxPyApp *) 0 ;
23235 wxWindow *arg2 = (wxWindow *) 0 ;
23236 wxIdleEvent *arg3 = 0 ;
23237 bool result;
23238 PyObject * obj0 = 0 ;
23239 PyObject * obj1 = 0 ;
23240 PyObject * obj2 = 0 ;
23241 char *kwnames[] = {
23242 (char *) "self",(char *) "win",(char *) "event", NULL
23243 };
23244
23245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23247 if (SWIG_arg_fail(1)) SWIG_fail;
23248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23249 if (SWIG_arg_fail(2)) SWIG_fail;
23250 {
23251 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23252 if (SWIG_arg_fail(3)) SWIG_fail;
23253 if (arg3 == NULL) {
23254 SWIG_null_ref("wxIdleEvent");
23255 }
23256 if (SWIG_arg_fail(3)) SWIG_fail;
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 wxPyApp *arg1 = (wxPyApp *) 0 ;
23277 bool result;
23278 PyObject * obj0 = 0 ;
23279 char *kwnames[] = {
23280 (char *) "self", NULL
23281 };
23282
23283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23285 if (SWIG_arg_fail(1)) SWIG_fail;
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (bool)((wxPyApp const *)arg1)->IsActive();
23289
23290 wxPyEndAllowThreads(__tstate);
23291 if (PyErr_Occurred()) SWIG_fail;
23292 }
23293 {
23294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23295 }
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23303 PyObject *resultobj;
23304 wxPyApp *arg1 = (wxPyApp *) 0 ;
23305 wxWindow *arg2 = (wxWindow *) 0 ;
23306 PyObject * obj0 = 0 ;
23307 PyObject * obj1 = 0 ;
23308 char *kwnames[] = {
23309 (char *) "self",(char *) "win", NULL
23310 };
23311
23312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23314 if (SWIG_arg_fail(1)) SWIG_fail;
23315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23316 if (SWIG_arg_fail(2)) SWIG_fail;
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 (arg1)->SetTopWindow(arg2);
23320
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 Py_INCREF(Py_None); resultobj = Py_None;
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj;
23333 wxPyApp *arg1 = (wxPyApp *) 0 ;
23334 wxWindow *result;
23335 PyObject * obj0 = 0 ;
23336 char *kwnames[] = {
23337 (char *) "self", NULL
23338 };
23339
23340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23342 if (SWIG_arg_fail(1)) SWIG_fail;
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23346
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 {
23351 resultobj = wxPyMake_wxObject(result, 0);
23352 }
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj;
23361 wxPyApp *arg1 = (wxPyApp *) 0 ;
23362 bool arg2 ;
23363 PyObject * obj0 = 0 ;
23364 PyObject * obj1 = 0 ;
23365 char *kwnames[] = {
23366 (char *) "self",(char *) "flag", NULL
23367 };
23368
23369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23371 if (SWIG_arg_fail(1)) SWIG_fail;
23372 {
23373 arg2 = (bool)(SWIG_As_bool(obj1));
23374 if (SWIG_arg_fail(2)) SWIG_fail;
23375 }
23376 {
23377 PyThreadState* __tstate = wxPyBeginAllowThreads();
23378 (arg1)->SetExitOnFrameDelete(arg2);
23379
23380 wxPyEndAllowThreads(__tstate);
23381 if (PyErr_Occurred()) SWIG_fail;
23382 }
23383 Py_INCREF(Py_None); resultobj = Py_None;
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj;
23392 wxPyApp *arg1 = (wxPyApp *) 0 ;
23393 bool result;
23394 PyObject * obj0 = 0 ;
23395 char *kwnames[] = {
23396 (char *) "self", NULL
23397 };
23398
23399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23401 if (SWIG_arg_fail(1)) SWIG_fail;
23402 {
23403 PyThreadState* __tstate = wxPyBeginAllowThreads();
23404 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23405
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 {
23410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23411 }
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23419 PyObject *resultobj;
23420 wxPyApp *arg1 = (wxPyApp *) 0 ;
23421 bool arg2 ;
23422 PyObject * obj0 = 0 ;
23423 PyObject * obj1 = 0 ;
23424 char *kwnames[] = {
23425 (char *) "self",(char *) "flag", NULL
23426 };
23427
23428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23430 if (SWIG_arg_fail(1)) SWIG_fail;
23431 {
23432 arg2 = (bool)(SWIG_As_bool(obj1));
23433 if (SWIG_arg_fail(2)) SWIG_fail;
23434 }
23435 {
23436 PyThreadState* __tstate = wxPyBeginAllowThreads();
23437 (arg1)->SetUseBestVisual(arg2);
23438
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 Py_INCREF(Py_None); resultobj = Py_None;
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj;
23451 wxPyApp *arg1 = (wxPyApp *) 0 ;
23452 bool result;
23453 PyObject * obj0 = 0 ;
23454 char *kwnames[] = {
23455 (char *) "self", NULL
23456 };
23457
23458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23460 if (SWIG_arg_fail(1)) SWIG_fail;
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23464
23465 wxPyEndAllowThreads(__tstate);
23466 if (PyErr_Occurred()) SWIG_fail;
23467 }
23468 {
23469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23470 }
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj;
23479 wxPyApp *arg1 = (wxPyApp *) 0 ;
23480 int arg2 ;
23481 PyObject * obj0 = 0 ;
23482 PyObject * obj1 = 0 ;
23483 char *kwnames[] = {
23484 (char *) "self",(char *) "mode", NULL
23485 };
23486
23487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23489 if (SWIG_arg_fail(1)) SWIG_fail;
23490 {
23491 arg2 = (int)(SWIG_As_int(obj1));
23492 if (SWIG_arg_fail(2)) SWIG_fail;
23493 }
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 (arg1)->SetPrintMode(arg2);
23497
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 Py_INCREF(Py_None); resultobj = Py_None;
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23509 PyObject *resultobj;
23510 wxPyApp *arg1 = (wxPyApp *) 0 ;
23511 int result;
23512 PyObject * obj0 = 0 ;
23513 char *kwnames[] = {
23514 (char *) "self", NULL
23515 };
23516
23517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23519 if (SWIG_arg_fail(1)) SWIG_fail;
23520 {
23521 PyThreadState* __tstate = wxPyBeginAllowThreads();
23522 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23523
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 {
23528 resultobj = SWIG_From_int((int)(result));
23529 }
23530 return resultobj;
23531 fail:
23532 return NULL;
23533 }
23534
23535
23536 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23537 PyObject *resultobj;
23538 wxPyApp *arg1 = (wxPyApp *) 0 ;
23539 int arg2 ;
23540 PyObject * obj0 = 0 ;
23541 PyObject * obj1 = 0 ;
23542 char *kwnames[] = {
23543 (char *) "self",(char *) "mode", NULL
23544 };
23545
23546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23548 if (SWIG_arg_fail(1)) SWIG_fail;
23549 {
23550 arg2 = (int)(SWIG_As_int(obj1));
23551 if (SWIG_arg_fail(2)) SWIG_fail;
23552 }
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 (arg1)->SetAssertMode(arg2);
23556
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 Py_INCREF(Py_None); resultobj = Py_None;
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj;
23569 wxPyApp *arg1 = (wxPyApp *) 0 ;
23570 int result;
23571 PyObject * obj0 = 0 ;
23572 char *kwnames[] = {
23573 (char *) "self", NULL
23574 };
23575
23576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23578 if (SWIG_arg_fail(1)) SWIG_fail;
23579 {
23580 PyThreadState* __tstate = wxPyBeginAllowThreads();
23581 result = (int)(arg1)->GetAssertMode();
23582
23583 wxPyEndAllowThreads(__tstate);
23584 if (PyErr_Occurred()) SWIG_fail;
23585 }
23586 {
23587 resultobj = SWIG_From_int((int)(result));
23588 }
23589 return resultobj;
23590 fail:
23591 return NULL;
23592 }
23593
23594
23595 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23596 PyObject *resultobj;
23597 bool result;
23598 char *kwnames[] = {
23599 NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23606
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23612 }
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj;
23621 long result;
23622 char *kwnames[] = {
23623 NULL
23624 };
23625
23626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 result = (long)wxPyApp::GetMacAboutMenuItemId();
23630
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 {
23635 resultobj = SWIG_From_long((long)(result));
23636 }
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 long result;
23646 char *kwnames[] = {
23647 NULL
23648 };
23649
23650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23651 {
23652 PyThreadState* __tstate = wxPyBeginAllowThreads();
23653 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23654
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = SWIG_From_long((long)(result));
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj;
23669 long result;
23670 char *kwnames[] = {
23671 NULL
23672 };
23673
23674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23675 {
23676 PyThreadState* __tstate = wxPyBeginAllowThreads();
23677 result = (long)wxPyApp::GetMacExitMenuItemId();
23678
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 {
23683 resultobj = SWIG_From_long((long)(result));
23684 }
23685 return resultobj;
23686 fail:
23687 return NULL;
23688 }
23689
23690
23691 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23692 PyObject *resultobj;
23693 wxString result;
23694 char *kwnames[] = {
23695 NULL
23696 };
23697
23698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 result = wxPyApp::GetMacHelpMenuTitleName();
23702
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 {
23707 #if wxUSE_UNICODE
23708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23709 #else
23710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23711 #endif
23712 }
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj;
23721 bool arg1 ;
23722 PyObject * obj0 = 0 ;
23723 char *kwnames[] = {
23724 (char *) "val", NULL
23725 };
23726
23727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23728 {
23729 arg1 = (bool)(SWIG_As_bool(obj0));
23730 if (SWIG_arg_fail(1)) SWIG_fail;
23731 }
23732 {
23733 PyThreadState* __tstate = wxPyBeginAllowThreads();
23734 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23735
23736 wxPyEndAllowThreads(__tstate);
23737 if (PyErr_Occurred()) SWIG_fail;
23738 }
23739 Py_INCREF(Py_None); resultobj = Py_None;
23740 return resultobj;
23741 fail:
23742 return NULL;
23743 }
23744
23745
23746 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23747 PyObject *resultobj;
23748 long arg1 ;
23749 PyObject * obj0 = 0 ;
23750 char *kwnames[] = {
23751 (char *) "val", NULL
23752 };
23753
23754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23755 {
23756 arg1 = (long)(SWIG_As_long(obj0));
23757 if (SWIG_arg_fail(1)) SWIG_fail;
23758 }
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 wxPyApp::SetMacAboutMenuItemId(arg1);
23762
23763 wxPyEndAllowThreads(__tstate);
23764 if (PyErr_Occurred()) SWIG_fail;
23765 }
23766 Py_INCREF(Py_None); resultobj = Py_None;
23767 return resultobj;
23768 fail:
23769 return NULL;
23770 }
23771
23772
23773 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23774 PyObject *resultobj;
23775 long arg1 ;
23776 PyObject * obj0 = 0 ;
23777 char *kwnames[] = {
23778 (char *) "val", NULL
23779 };
23780
23781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23782 {
23783 arg1 = (long)(SWIG_As_long(obj0));
23784 if (SWIG_arg_fail(1)) SWIG_fail;
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23789
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 Py_INCREF(Py_None); resultobj = Py_None;
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23801 PyObject *resultobj;
23802 long arg1 ;
23803 PyObject * obj0 = 0 ;
23804 char *kwnames[] = {
23805 (char *) "val", NULL
23806 };
23807
23808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23809 {
23810 arg1 = (long)(SWIG_As_long(obj0));
23811 if (SWIG_arg_fail(1)) SWIG_fail;
23812 }
23813 {
23814 PyThreadState* __tstate = wxPyBeginAllowThreads();
23815 wxPyApp::SetMacExitMenuItemId(arg1);
23816
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 Py_INCREF(Py_None); resultobj = Py_None;
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23828 PyObject *resultobj;
23829 wxString *arg1 = 0 ;
23830 bool temp1 = false ;
23831 PyObject * obj0 = 0 ;
23832 char *kwnames[] = {
23833 (char *) "val", NULL
23834 };
23835
23836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23837 {
23838 arg1 = wxString_in_helper(obj0);
23839 if (arg1 == NULL) SWIG_fail;
23840 temp1 = true;
23841 }
23842 {
23843 PyThreadState* __tstate = wxPyBeginAllowThreads();
23844 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23845
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 Py_INCREF(Py_None); resultobj = Py_None;
23850 {
23851 if (temp1)
23852 delete arg1;
23853 }
23854 return resultobj;
23855 fail:
23856 {
23857 if (temp1)
23858 delete arg1;
23859 }
23860 return NULL;
23861 }
23862
23863
23864 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj;
23866 wxPyApp *arg1 = (wxPyApp *) 0 ;
23867 PyObject * obj0 = 0 ;
23868 char *kwnames[] = {
23869 (char *) "self", NULL
23870 };
23871
23872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23874 if (SWIG_arg_fail(1)) SWIG_fail;
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 (arg1)->_BootstrapApp();
23878
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 Py_INCREF(Py_None); resultobj = Py_None;
23883 return resultobj;
23884 fail:
23885 return NULL;
23886 }
23887
23888
23889 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23890 PyObject *resultobj;
23891 int result;
23892 char *kwnames[] = {
23893 NULL
23894 };
23895
23896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = (int)PyApp_GetComCtl32Version();
23900
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 resultobj = SWIG_From_int((int)(result));
23906 }
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23914 PyObject *obj;
23915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23916 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23917 Py_INCREF(obj);
23918 return Py_BuildValue((char *)"");
23919 }
23920 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23921 PyObject *resultobj;
23922 char *kwnames[] = {
23923 NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23927 {
23928 PyThreadState* __tstate = wxPyBeginAllowThreads();
23929 wxExit();
23930
23931 wxPyEndAllowThreads(__tstate);
23932 if (PyErr_Occurred()) SWIG_fail;
23933 }
23934 Py_INCREF(Py_None); resultobj = Py_None;
23935 return resultobj;
23936 fail:
23937 return NULL;
23938 }
23939
23940
23941 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23942 PyObject *resultobj;
23943 bool result;
23944 char *kwnames[] = {
23945 NULL
23946 };
23947
23948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 result = (bool)wxYield();
23952
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 {
23957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23958 }
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23966 PyObject *resultobj;
23967 bool result;
23968 char *kwnames[] = {
23969 NULL
23970 };
23971
23972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23973 {
23974 PyThreadState* __tstate = wxPyBeginAllowThreads();
23975 result = (bool)wxYieldIfNeeded();
23976
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 {
23981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23982 }
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23990 PyObject *resultobj;
23991 wxWindow *arg1 = (wxWindow *) NULL ;
23992 bool arg2 = (bool) false ;
23993 bool result;
23994 PyObject * obj0 = 0 ;
23995 PyObject * obj1 = 0 ;
23996 char *kwnames[] = {
23997 (char *) "win",(char *) "onlyIfNeeded", NULL
23998 };
23999
24000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24001 if (obj0) {
24002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24003 if (SWIG_arg_fail(1)) SWIG_fail;
24004 }
24005 if (obj1) {
24006 {
24007 arg2 = (bool)(SWIG_As_bool(obj1));
24008 if (SWIG_arg_fail(2)) SWIG_fail;
24009 }
24010 }
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 result = (bool)wxSafeYield(arg1,arg2);
24014
24015 wxPyEndAllowThreads(__tstate);
24016 if (PyErr_Occurred()) SWIG_fail;
24017 }
24018 {
24019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24020 }
24021 return resultobj;
24022 fail:
24023 return NULL;
24024 }
24025
24026
24027 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24028 PyObject *resultobj;
24029 char *kwnames[] = {
24030 NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 wxWakeUpIdle();
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 Py_INCREF(Py_None); resultobj = Py_None;
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24051 wxEvent *arg2 = 0 ;
24052 PyObject * obj0 = 0 ;
24053 PyObject * obj1 = 0 ;
24054 char *kwnames[] = {
24055 (char *) "dest",(char *) "event", NULL
24056 };
24057
24058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24060 if (SWIG_arg_fail(1)) SWIG_fail;
24061 {
24062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24063 if (SWIG_arg_fail(2)) SWIG_fail;
24064 if (arg2 == NULL) {
24065 SWIG_null_ref("wxEvent");
24066 }
24067 if (SWIG_arg_fail(2)) SWIG_fail;
24068 }
24069 {
24070 PyThreadState* __tstate = wxPyBeginAllowThreads();
24071 wxPostEvent(arg1,*arg2);
24072
24073 wxPyEndAllowThreads(__tstate);
24074 if (PyErr_Occurred()) SWIG_fail;
24075 }
24076 Py_INCREF(Py_None); resultobj = Py_None;
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24084 PyObject *resultobj;
24085 char *kwnames[] = {
24086 NULL
24087 };
24088
24089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24090 {
24091 PyThreadState* __tstate = wxPyBeginAllowThreads();
24092 wxApp_CleanUp();
24093
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 Py_INCREF(Py_None); resultobj = Py_None;
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj;
24106 wxPyApp *result;
24107 char *kwnames[] = {
24108 NULL
24109 };
24110
24111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 result = (wxPyApp *)wxPyGetApp();
24115
24116 wxPyEndAllowThreads(__tstate);
24117 if (PyErr_Occurred()) SWIG_fail;
24118 }
24119 {
24120 resultobj = wxPyMake_wxObject(result, 0);
24121 }
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24129 PyObject *resultobj;
24130 char *arg1 = (char *) 0 ;
24131 PyObject * obj0 = 0 ;
24132 char *kwnames[] = {
24133 (char *) "encoding", NULL
24134 };
24135
24136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24137 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24138 SWIG_arg_fail(1);SWIG_fail;
24139 }
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 wxSetDefaultPyEncoding((char const *)arg1);
24143
24144 wxPyEndAllowThreads(__tstate);
24145 if (PyErr_Occurred()) SWIG_fail;
24146 }
24147 Py_INCREF(Py_None); resultobj = Py_None;
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24155 PyObject *resultobj;
24156 char *result;
24157 char *kwnames[] = {
24158 NULL
24159 };
24160
24161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = (char *)wxGetDefaultPyEncoding();
24165
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 resultobj = SWIG_FromCharPtr(result);
24170 return resultobj;
24171 fail:
24172 return NULL;
24173 }
24174
24175
24176 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24177 PyObject *resultobj;
24178 wxEventLoop *result;
24179 char *kwnames[] = {
24180 NULL
24181 };
24182
24183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 result = (wxEventLoop *)new wxEventLoop();
24187
24188 wxPyEndAllowThreads(__tstate);
24189 if (PyErr_Occurred()) SWIG_fail;
24190 }
24191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj;
24200 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24201 PyObject * obj0 = 0 ;
24202 char *kwnames[] = {
24203 (char *) "self", NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24208 if (SWIG_arg_fail(1)) SWIG_fail;
24209 {
24210 PyThreadState* __tstate = wxPyBeginAllowThreads();
24211 delete arg1;
24212
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 Py_INCREF(Py_None); resultobj = Py_None;
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj;
24225 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24226 int result;
24227 PyObject * obj0 = 0 ;
24228 char *kwnames[] = {
24229 (char *) "self", NULL
24230 };
24231
24232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24234 if (SWIG_arg_fail(1)) SWIG_fail;
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 result = (int)(arg1)->Run();
24238
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 {
24243 resultobj = SWIG_From_int((int)(result));
24244 }
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24252 PyObject *resultobj;
24253 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24254 int arg2 = (int) 0 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self",(char *) "rc", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 if (obj1) {
24265 {
24266 arg2 = (int)(SWIG_As_int(obj1));
24267 if (SWIG_arg_fail(2)) SWIG_fail;
24268 }
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 (arg1)->Exit(arg2);
24273
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 Py_INCREF(Py_None); resultobj = Py_None;
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj;
24286 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24287 bool result;
24288 PyObject * obj0 = 0 ;
24289 char *kwnames[] = {
24290 (char *) "self", NULL
24291 };
24292
24293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24295 if (SWIG_arg_fail(1)) SWIG_fail;
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (bool)((wxEventLoop const *)arg1)->Pending();
24299
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24305 }
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj;
24314 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24315 bool result;
24316 PyObject * obj0 = 0 ;
24317 char *kwnames[] = {
24318 (char *) "self", NULL
24319 };
24320
24321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24323 if (SWIG_arg_fail(1)) SWIG_fail;
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (bool)(arg1)->Dispatch();
24327
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 {
24332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24333 }
24334 return resultobj;
24335 fail:
24336 return NULL;
24337 }
24338
24339
24340 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24341 PyObject *resultobj;
24342 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24343 bool result;
24344 PyObject * obj0 = 0 ;
24345 char *kwnames[] = {
24346 (char *) "self", NULL
24347 };
24348
24349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24351 if (SWIG_arg_fail(1)) SWIG_fail;
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24355
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 {
24360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24361 }
24362 return resultobj;
24363 fail:
24364 return NULL;
24365 }
24366
24367
24368 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24369 PyObject *resultobj;
24370 wxEventLoop *result;
24371 char *kwnames[] = {
24372 NULL
24373 };
24374
24375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 result = (wxEventLoop *)wxEventLoop::GetActive();
24379
24380 wxPyEndAllowThreads(__tstate);
24381 if (PyErr_Occurred()) SWIG_fail;
24382 }
24383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24391 PyObject *resultobj;
24392 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24393 PyObject * obj0 = 0 ;
24394 char *kwnames[] = {
24395 (char *) "loop", NULL
24396 };
24397
24398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24400 if (SWIG_arg_fail(1)) SWIG_fail;
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 wxEventLoop::SetActive(arg1);
24404
24405 wxPyEndAllowThreads(__tstate);
24406 if (PyErr_Occurred()) SWIG_fail;
24407 }
24408 Py_INCREF(Py_None); resultobj = Py_None;
24409 return resultobj;
24410 fail:
24411 return NULL;
24412 }
24413
24414
24415 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24416 PyObject *obj;
24417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24418 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24419 Py_INCREF(obj);
24420 return Py_BuildValue((char *)"");
24421 }
24422 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24423 PyObject *resultobj;
24424 int arg1 = (int) 0 ;
24425 int arg2 = (int) 0 ;
24426 int arg3 = (int) 0 ;
24427 wxAcceleratorEntry *result;
24428 PyObject * obj0 = 0 ;
24429 PyObject * obj1 = 0 ;
24430 PyObject * obj2 = 0 ;
24431 char *kwnames[] = {
24432 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24433 };
24434
24435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24436 if (obj0) {
24437 {
24438 arg1 = (int)(SWIG_As_int(obj0));
24439 if (SWIG_arg_fail(1)) SWIG_fail;
24440 }
24441 }
24442 if (obj1) {
24443 {
24444 arg2 = (int)(SWIG_As_int(obj1));
24445 if (SWIG_arg_fail(2)) SWIG_fail;
24446 }
24447 }
24448 if (obj2) {
24449 {
24450 arg3 = (int)(SWIG_As_int(obj2));
24451 if (SWIG_arg_fail(3)) SWIG_fail;
24452 }
24453 }
24454 {
24455 PyThreadState* __tstate = wxPyBeginAllowThreads();
24456 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24457
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24462 return resultobj;
24463 fail:
24464 return NULL;
24465 }
24466
24467
24468 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24469 PyObject *resultobj;
24470 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24471 PyObject * obj0 = 0 ;
24472 char *kwnames[] = {
24473 (char *) "self", NULL
24474 };
24475
24476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24478 if (SWIG_arg_fail(1)) SWIG_fail;
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 delete arg1;
24482
24483 wxPyEndAllowThreads(__tstate);
24484 if (PyErr_Occurred()) SWIG_fail;
24485 }
24486 Py_INCREF(Py_None); resultobj = Py_None;
24487 return resultobj;
24488 fail:
24489 return NULL;
24490 }
24491
24492
24493 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24494 PyObject *resultobj;
24495 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24496 int arg2 ;
24497 int arg3 ;
24498 int arg4 ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 PyObject * obj2 = 0 ;
24502 PyObject * obj3 = 0 ;
24503 char *kwnames[] = {
24504 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24505 };
24506
24507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24509 if (SWIG_arg_fail(1)) SWIG_fail;
24510 {
24511 arg2 = (int)(SWIG_As_int(obj1));
24512 if (SWIG_arg_fail(2)) SWIG_fail;
24513 }
24514 {
24515 arg3 = (int)(SWIG_As_int(obj2));
24516 if (SWIG_arg_fail(3)) SWIG_fail;
24517 }
24518 {
24519 arg4 = (int)(SWIG_As_int(obj3));
24520 if (SWIG_arg_fail(4)) SWIG_fail;
24521 }
24522 {
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 (arg1)->Set(arg2,arg3,arg4);
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 Py_INCREF(Py_None); resultobj = Py_None;
24530 return resultobj;
24531 fail:
24532 return NULL;
24533 }
24534
24535
24536 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24537 PyObject *resultobj;
24538 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24539 int result;
24540 PyObject * obj0 = 0 ;
24541 char *kwnames[] = {
24542 (char *) "self", NULL
24543 };
24544
24545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24547 if (SWIG_arg_fail(1)) SWIG_fail;
24548 {
24549 PyThreadState* __tstate = wxPyBeginAllowThreads();
24550 result = (int)(arg1)->GetFlags();
24551
24552 wxPyEndAllowThreads(__tstate);
24553 if (PyErr_Occurred()) SWIG_fail;
24554 }
24555 {
24556 resultobj = SWIG_From_int((int)(result));
24557 }
24558 return resultobj;
24559 fail:
24560 return NULL;
24561 }
24562
24563
24564 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj;
24566 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24567 int result;
24568 PyObject * obj0 = 0 ;
24569 char *kwnames[] = {
24570 (char *) "self", NULL
24571 };
24572
24573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24575 if (SWIG_arg_fail(1)) SWIG_fail;
24576 {
24577 PyThreadState* __tstate = wxPyBeginAllowThreads();
24578 result = (int)(arg1)->GetKeyCode();
24579
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 {
24584 resultobj = SWIG_From_int((int)(result));
24585 }
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24593 PyObject *resultobj;
24594 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24595 int result;
24596 PyObject * obj0 = 0 ;
24597 char *kwnames[] = {
24598 (char *) "self", NULL
24599 };
24600
24601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24603 if (SWIG_arg_fail(1)) SWIG_fail;
24604 {
24605 PyThreadState* __tstate = wxPyBeginAllowThreads();
24606 result = (int)(arg1)->GetCommand();
24607
24608 wxPyEndAllowThreads(__tstate);
24609 if (PyErr_Occurred()) SWIG_fail;
24610 }
24611 {
24612 resultobj = SWIG_From_int((int)(result));
24613 }
24614 return resultobj;
24615 fail:
24616 return NULL;
24617 }
24618
24619
24620 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24621 PyObject *obj;
24622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24623 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24624 Py_INCREF(obj);
24625 return Py_BuildValue((char *)"");
24626 }
24627 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24628 PyObject *resultobj;
24629 int arg1 ;
24630 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24631 wxAcceleratorTable *result;
24632 PyObject * obj0 = 0 ;
24633 char *kwnames[] = {
24634 (char *) "n", NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24638 {
24639 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24640 if (arg2) arg1 = PyList_Size(obj0);
24641 else arg1 = 0;
24642 }
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24646
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24651 {
24652 delete [] arg2;
24653 }
24654 return resultobj;
24655 fail:
24656 {
24657 delete [] arg2;
24658 }
24659 return NULL;
24660 }
24661
24662
24663 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24664 PyObject *resultobj;
24665 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24666 PyObject * obj0 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 delete arg1;
24677
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 Py_INCREF(Py_None); resultobj = Py_None;
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24689 PyObject *resultobj;
24690 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24691 bool result;
24692 PyObject * obj0 = 0 ;
24693 char *kwnames[] = {
24694 (char *) "self", NULL
24695 };
24696
24697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24699 if (SWIG_arg_fail(1)) SWIG_fail;
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24703
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 {
24708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24709 }
24710 return resultobj;
24711 fail:
24712 return NULL;
24713 }
24714
24715
24716 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24717 PyObject *obj;
24718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24719 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24720 Py_INCREF(obj);
24721 return Py_BuildValue((char *)"");
24722 }
24723 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24724 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24725 return 1;
24726 }
24727
24728
24729 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24730 PyObject *pyobj;
24731
24732 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24733 return pyobj;
24734 }
24735
24736
24737 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24738 PyObject *resultobj;
24739 wxString *arg1 = 0 ;
24740 wxAcceleratorEntry *result;
24741 bool temp1 = false ;
24742 PyObject * obj0 = 0 ;
24743 char *kwnames[] = {
24744 (char *) "label", NULL
24745 };
24746
24747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24748 {
24749 arg1 = wxString_in_helper(obj0);
24750 if (arg1 == NULL) SWIG_fail;
24751 temp1 = true;
24752 }
24753 {
24754 PyThreadState* __tstate = wxPyBeginAllowThreads();
24755 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24756
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24761 {
24762 if (temp1)
24763 delete arg1;
24764 }
24765 return resultobj;
24766 fail:
24767 {
24768 if (temp1)
24769 delete arg1;
24770 }
24771 return NULL;
24772 }
24773
24774
24775 static int _wrap_PanelNameStr_set(PyObject *) {
24776 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24777 return 1;
24778 }
24779
24780
24781 static PyObject *_wrap_PanelNameStr_get(void) {
24782 PyObject *pyobj;
24783
24784 {
24785 #if wxUSE_UNICODE
24786 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24787 #else
24788 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24789 #endif
24790 }
24791 return pyobj;
24792 }
24793
24794
24795 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24796 PyObject *resultobj;
24797 wxVisualAttributes *result;
24798 char *kwnames[] = {
24799 NULL
24800 };
24801
24802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (wxVisualAttributes *)new_wxVisualAttributes();
24806
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24811 return resultobj;
24812 fail:
24813 return NULL;
24814 }
24815
24816
24817 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24818 PyObject *resultobj;
24819 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24820 PyObject * obj0 = 0 ;
24821 char *kwnames[] = {
24822 (char *) "self", NULL
24823 };
24824
24825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24827 if (SWIG_arg_fail(1)) SWIG_fail;
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 delete_wxVisualAttributes(arg1);
24831
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 Py_INCREF(Py_None); resultobj = Py_None;
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24843 PyObject *resultobj;
24844 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24845 wxFont *arg2 = (wxFont *) 0 ;
24846 PyObject * obj0 = 0 ;
24847 PyObject * obj1 = 0 ;
24848 char *kwnames[] = {
24849 (char *) "self",(char *) "font", NULL
24850 };
24851
24852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24856 if (SWIG_arg_fail(2)) SWIG_fail;
24857 if (arg1) (arg1)->font = *arg2;
24858
24859 Py_INCREF(Py_None); resultobj = Py_None;
24860 return resultobj;
24861 fail:
24862 return NULL;
24863 }
24864
24865
24866 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24867 PyObject *resultobj;
24868 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24869 wxFont *result;
24870 PyObject * obj0 = 0 ;
24871 char *kwnames[] = {
24872 (char *) "self", NULL
24873 };
24874
24875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24877 if (SWIG_arg_fail(1)) SWIG_fail;
24878 result = (wxFont *)& ((arg1)->font);
24879
24880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24888 PyObject *resultobj;
24889 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24890 wxColour *arg2 = (wxColour *) 0 ;
24891 PyObject * obj0 = 0 ;
24892 PyObject * obj1 = 0 ;
24893 char *kwnames[] = {
24894 (char *) "self",(char *) "colFg", NULL
24895 };
24896
24897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24901 if (SWIG_arg_fail(2)) SWIG_fail;
24902 if (arg1) (arg1)->colFg = *arg2;
24903
24904 Py_INCREF(Py_None); resultobj = Py_None;
24905 return resultobj;
24906 fail:
24907 return NULL;
24908 }
24909
24910
24911 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24912 PyObject *resultobj;
24913 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24914 wxColour *result;
24915 PyObject * obj0 = 0 ;
24916 char *kwnames[] = {
24917 (char *) "self", NULL
24918 };
24919
24920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24922 if (SWIG_arg_fail(1)) SWIG_fail;
24923 result = (wxColour *)& ((arg1)->colFg);
24924
24925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24933 PyObject *resultobj;
24934 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24935 wxColour *arg2 = (wxColour *) 0 ;
24936 PyObject * obj0 = 0 ;
24937 PyObject * obj1 = 0 ;
24938 char *kwnames[] = {
24939 (char *) "self",(char *) "colBg", NULL
24940 };
24941
24942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24946 if (SWIG_arg_fail(2)) SWIG_fail;
24947 if (arg1) (arg1)->colBg = *arg2;
24948
24949 Py_INCREF(Py_None); resultobj = Py_None;
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj;
24958 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24959 wxColour *result;
24960 PyObject * obj0 = 0 ;
24961 char *kwnames[] = {
24962 (char *) "self", NULL
24963 };
24964
24965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24967 if (SWIG_arg_fail(1)) SWIG_fail;
24968 result = (wxColour *)& ((arg1)->colBg);
24969
24970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24978 PyObject *obj;
24979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24980 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24981 Py_INCREF(obj);
24982 return Py_BuildValue((char *)"");
24983 }
24984 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24985 PyObject *resultobj;
24986 wxWindow *arg1 = (wxWindow *) 0 ;
24987 int arg2 = (int) (int)-1 ;
24988 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24989 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24990 wxSize const &arg4_defvalue = wxDefaultSize ;
24991 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24992 long arg5 = (long) 0 ;
24993 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24994 wxString *arg6 = (wxString *) &arg6_defvalue ;
24995 wxWindow *result;
24996 wxPoint temp3 ;
24997 wxSize temp4 ;
24998 bool temp6 = false ;
24999 PyObject * obj0 = 0 ;
25000 PyObject * obj1 = 0 ;
25001 PyObject * obj2 = 0 ;
25002 PyObject * obj3 = 0 ;
25003 PyObject * obj4 = 0 ;
25004 PyObject * obj5 = 0 ;
25005 char *kwnames[] = {
25006 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25007 };
25008
25009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25011 if (SWIG_arg_fail(1)) SWIG_fail;
25012 if (obj1) {
25013 {
25014 arg2 = (int const)(SWIG_As_int(obj1));
25015 if (SWIG_arg_fail(2)) SWIG_fail;
25016 }
25017 }
25018 if (obj2) {
25019 {
25020 arg3 = &temp3;
25021 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25022 }
25023 }
25024 if (obj3) {
25025 {
25026 arg4 = &temp4;
25027 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25028 }
25029 }
25030 if (obj4) {
25031 {
25032 arg5 = (long)(SWIG_As_long(obj4));
25033 if (SWIG_arg_fail(5)) SWIG_fail;
25034 }
25035 }
25036 if (obj5) {
25037 {
25038 arg6 = wxString_in_helper(obj5);
25039 if (arg6 == NULL) SWIG_fail;
25040 temp6 = true;
25041 }
25042 }
25043 {
25044 if (!wxPyCheckForApp()) SWIG_fail;
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25047
25048 wxPyEndAllowThreads(__tstate);
25049 if (PyErr_Occurred()) SWIG_fail;
25050 }
25051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25052 {
25053 if (temp6)
25054 delete arg6;
25055 }
25056 return resultobj;
25057 fail:
25058 {
25059 if (temp6)
25060 delete arg6;
25061 }
25062 return NULL;
25063 }
25064
25065
25066 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25067 PyObject *resultobj;
25068 wxWindow *result;
25069 char *kwnames[] = {
25070 NULL
25071 };
25072
25073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25074 {
25075 if (!wxPyCheckForApp()) SWIG_fail;
25076 PyThreadState* __tstate = wxPyBeginAllowThreads();
25077 result = (wxWindow *)new wxWindow();
25078
25079 wxPyEndAllowThreads(__tstate);
25080 if (PyErr_Occurred()) SWIG_fail;
25081 }
25082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25083 return resultobj;
25084 fail:
25085 return NULL;
25086 }
25087
25088
25089 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25090 PyObject *resultobj;
25091 wxWindow *arg1 = (wxWindow *) 0 ;
25092 wxWindow *arg2 = (wxWindow *) 0 ;
25093 int arg3 = (int) (int)-1 ;
25094 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25095 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25096 wxSize const &arg5_defvalue = wxDefaultSize ;
25097 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25098 long arg6 = (long) 0 ;
25099 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25100 wxString *arg7 = (wxString *) &arg7_defvalue ;
25101 bool result;
25102 wxPoint temp4 ;
25103 wxSize temp5 ;
25104 bool temp7 = false ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 PyObject * obj2 = 0 ;
25108 PyObject * obj3 = 0 ;
25109 PyObject * obj4 = 0 ;
25110 PyObject * obj5 = 0 ;
25111 PyObject * obj6 = 0 ;
25112 char *kwnames[] = {
25113 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25114 };
25115
25116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25118 if (SWIG_arg_fail(1)) SWIG_fail;
25119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25120 if (SWIG_arg_fail(2)) SWIG_fail;
25121 if (obj2) {
25122 {
25123 arg3 = (int const)(SWIG_As_int(obj2));
25124 if (SWIG_arg_fail(3)) SWIG_fail;
25125 }
25126 }
25127 if (obj3) {
25128 {
25129 arg4 = &temp4;
25130 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25131 }
25132 }
25133 if (obj4) {
25134 {
25135 arg5 = &temp5;
25136 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25137 }
25138 }
25139 if (obj5) {
25140 {
25141 arg6 = (long)(SWIG_As_long(obj5));
25142 if (SWIG_arg_fail(6)) SWIG_fail;
25143 }
25144 }
25145 if (obj6) {
25146 {
25147 arg7 = wxString_in_helper(obj6);
25148 if (arg7 == NULL) SWIG_fail;
25149 temp7 = true;
25150 }
25151 }
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25155
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25161 }
25162 {
25163 if (temp7)
25164 delete arg7;
25165 }
25166 return resultobj;
25167 fail:
25168 {
25169 if (temp7)
25170 delete arg7;
25171 }
25172 return NULL;
25173 }
25174
25175
25176 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25177 PyObject *resultobj;
25178 wxWindow *arg1 = (wxWindow *) 0 ;
25179 bool arg2 = (bool) false ;
25180 bool result;
25181 PyObject * obj0 = 0 ;
25182 PyObject * obj1 = 0 ;
25183 char *kwnames[] = {
25184 (char *) "self",(char *) "force", NULL
25185 };
25186
25187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25189 if (SWIG_arg_fail(1)) SWIG_fail;
25190 if (obj1) {
25191 {
25192 arg2 = (bool)(SWIG_As_bool(obj1));
25193 if (SWIG_arg_fail(2)) SWIG_fail;
25194 }
25195 }
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (bool)(arg1)->Close(arg2);
25199
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 {
25204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25205 }
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25213 PyObject *resultobj;
25214 wxWindow *arg1 = (wxWindow *) 0 ;
25215 bool result;
25216 PyObject * obj0 = 0 ;
25217 char *kwnames[] = {
25218 (char *) "self", NULL
25219 };
25220
25221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25223 if (SWIG_arg_fail(1)) SWIG_fail;
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (bool)(arg1)->Destroy();
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj;
25242 wxWindow *arg1 = (wxWindow *) 0 ;
25243 bool result;
25244 PyObject * obj0 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "self", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25251 if (SWIG_arg_fail(1)) SWIG_fail;
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (bool)(arg1)->DestroyChildren();
25255
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 {
25260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25261 }
25262 return resultobj;
25263 fail:
25264 return NULL;
25265 }
25266
25267
25268 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj;
25270 wxWindow *arg1 = (wxWindow *) 0 ;
25271 bool result;
25272 PyObject * obj0 = 0 ;
25273 char *kwnames[] = {
25274 (char *) "self", NULL
25275 };
25276
25277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25279 if (SWIG_arg_fail(1)) SWIG_fail;
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25283
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 {
25288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25289 }
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25297 PyObject *resultobj;
25298 wxWindow *arg1 = (wxWindow *) 0 ;
25299 wxString *arg2 = 0 ;
25300 bool temp2 = false ;
25301 PyObject * obj0 = 0 ;
25302 PyObject * obj1 = 0 ;
25303 char *kwnames[] = {
25304 (char *) "self",(char *) "title", NULL
25305 };
25306
25307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25309 if (SWIG_arg_fail(1)) SWIG_fail;
25310 {
25311 arg2 = wxString_in_helper(obj1);
25312 if (arg2 == NULL) SWIG_fail;
25313 temp2 = true;
25314 }
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 (arg1)->SetTitle((wxString const &)*arg2);
25318
25319 wxPyEndAllowThreads(__tstate);
25320 if (PyErr_Occurred()) SWIG_fail;
25321 }
25322 Py_INCREF(Py_None); resultobj = Py_None;
25323 {
25324 if (temp2)
25325 delete arg2;
25326 }
25327 return resultobj;
25328 fail:
25329 {
25330 if (temp2)
25331 delete arg2;
25332 }
25333 return NULL;
25334 }
25335
25336
25337 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj;
25339 wxWindow *arg1 = (wxWindow *) 0 ;
25340 wxString result;
25341 PyObject * obj0 = 0 ;
25342 char *kwnames[] = {
25343 (char *) "self", NULL
25344 };
25345
25346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25348 if (SWIG_arg_fail(1)) SWIG_fail;
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = ((wxWindow const *)arg1)->GetTitle();
25352
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 {
25357 #if wxUSE_UNICODE
25358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25359 #else
25360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25361 #endif
25362 }
25363 return resultobj;
25364 fail:
25365 return NULL;
25366 }
25367
25368
25369 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25370 PyObject *resultobj;
25371 wxWindow *arg1 = (wxWindow *) 0 ;
25372 wxString *arg2 = 0 ;
25373 bool temp2 = false ;
25374 PyObject * obj0 = 0 ;
25375 PyObject * obj1 = 0 ;
25376 char *kwnames[] = {
25377 (char *) "self",(char *) "label", NULL
25378 };
25379
25380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25382 if (SWIG_arg_fail(1)) SWIG_fail;
25383 {
25384 arg2 = wxString_in_helper(obj1);
25385 if (arg2 == NULL) SWIG_fail;
25386 temp2 = true;
25387 }
25388 {
25389 PyThreadState* __tstate = wxPyBeginAllowThreads();
25390 (arg1)->SetLabel((wxString const &)*arg2);
25391
25392 wxPyEndAllowThreads(__tstate);
25393 if (PyErr_Occurred()) SWIG_fail;
25394 }
25395 Py_INCREF(Py_None); resultobj = Py_None;
25396 {
25397 if (temp2)
25398 delete arg2;
25399 }
25400 return resultobj;
25401 fail:
25402 {
25403 if (temp2)
25404 delete arg2;
25405 }
25406 return NULL;
25407 }
25408
25409
25410 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25411 PyObject *resultobj;
25412 wxWindow *arg1 = (wxWindow *) 0 ;
25413 wxString result;
25414 PyObject * obj0 = 0 ;
25415 char *kwnames[] = {
25416 (char *) "self", NULL
25417 };
25418
25419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25421 if (SWIG_arg_fail(1)) SWIG_fail;
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 result = ((wxWindow const *)arg1)->GetLabel();
25425
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 {
25430 #if wxUSE_UNICODE
25431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25432 #else
25433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25434 #endif
25435 }
25436 return resultobj;
25437 fail:
25438 return NULL;
25439 }
25440
25441
25442 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25443 PyObject *resultobj;
25444 wxWindow *arg1 = (wxWindow *) 0 ;
25445 wxString *arg2 = 0 ;
25446 bool temp2 = false ;
25447 PyObject * obj0 = 0 ;
25448 PyObject * obj1 = 0 ;
25449 char *kwnames[] = {
25450 (char *) "self",(char *) "name", NULL
25451 };
25452
25453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25455 if (SWIG_arg_fail(1)) SWIG_fail;
25456 {
25457 arg2 = wxString_in_helper(obj1);
25458 if (arg2 == NULL) SWIG_fail;
25459 temp2 = true;
25460 }
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 (arg1)->SetName((wxString const &)*arg2);
25464
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 Py_INCREF(Py_None); resultobj = Py_None;
25469 {
25470 if (temp2)
25471 delete arg2;
25472 }
25473 return resultobj;
25474 fail:
25475 {
25476 if (temp2)
25477 delete arg2;
25478 }
25479 return NULL;
25480 }
25481
25482
25483 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25484 PyObject *resultobj;
25485 wxWindow *arg1 = (wxWindow *) 0 ;
25486 wxString result;
25487 PyObject * obj0 = 0 ;
25488 char *kwnames[] = {
25489 (char *) "self", NULL
25490 };
25491
25492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25494 if (SWIG_arg_fail(1)) SWIG_fail;
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 result = ((wxWindow const *)arg1)->GetName();
25498
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 {
25503 #if wxUSE_UNICODE
25504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25505 #else
25506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25507 #endif
25508 }
25509 return resultobj;
25510 fail:
25511 return NULL;
25512 }
25513
25514
25515 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25516 PyObject *resultobj;
25517 wxWindow *arg1 = (wxWindow *) 0 ;
25518 wxWindowVariant arg2 ;
25519 PyObject * obj0 = 0 ;
25520 PyObject * obj1 = 0 ;
25521 char *kwnames[] = {
25522 (char *) "self",(char *) "variant", NULL
25523 };
25524
25525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25527 if (SWIG_arg_fail(1)) SWIG_fail;
25528 {
25529 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25530 if (SWIG_arg_fail(2)) SWIG_fail;
25531 }
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25535
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 Py_INCREF(Py_None); resultobj = Py_None;
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 wxWindow *arg1 = (wxWindow *) 0 ;
25549 wxWindowVariant result;
25550 PyObject * obj0 = 0 ;
25551 char *kwnames[] = {
25552 (char *) "self", NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25557 if (SWIG_arg_fail(1)) SWIG_fail;
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25561
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 resultobj = SWIG_From_int((result));
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25573 PyObject *resultobj;
25574 wxWindow *arg1 = (wxWindow *) 0 ;
25575 int arg2 ;
25576 PyObject * obj0 = 0 ;
25577 PyObject * obj1 = 0 ;
25578 char *kwnames[] = {
25579 (char *) "self",(char *) "winid", NULL
25580 };
25581
25582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25584 if (SWIG_arg_fail(1)) SWIG_fail;
25585 {
25586 arg2 = (int)(SWIG_As_int(obj1));
25587 if (SWIG_arg_fail(2)) SWIG_fail;
25588 }
25589 {
25590 PyThreadState* __tstate = wxPyBeginAllowThreads();
25591 (arg1)->SetId(arg2);
25592
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 Py_INCREF(Py_None); resultobj = Py_None;
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25604 PyObject *resultobj;
25605 wxWindow *arg1 = (wxWindow *) 0 ;
25606 int result;
25607 PyObject * obj0 = 0 ;
25608 char *kwnames[] = {
25609 (char *) "self", NULL
25610 };
25611
25612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25614 if (SWIG_arg_fail(1)) SWIG_fail;
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = (int)((wxWindow const *)arg1)->GetId();
25618
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 {
25623 resultobj = SWIG_From_int((int)(result));
25624 }
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25632 PyObject *resultobj;
25633 int result;
25634 char *kwnames[] = {
25635 NULL
25636 };
25637
25638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 result = (int)wxWindow::NewControlId();
25642
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 {
25647 resultobj = SWIG_From_int((int)(result));
25648 }
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 int arg1 ;
25658 int result;
25659 PyObject * obj0 = 0 ;
25660 char *kwnames[] = {
25661 (char *) "winid", NULL
25662 };
25663
25664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25665 {
25666 arg1 = (int)(SWIG_As_int(obj0));
25667 if (SWIG_arg_fail(1)) SWIG_fail;
25668 }
25669 {
25670 PyThreadState* __tstate = wxPyBeginAllowThreads();
25671 result = (int)wxWindow::NextControlId(arg1);
25672
25673 wxPyEndAllowThreads(__tstate);
25674 if (PyErr_Occurred()) SWIG_fail;
25675 }
25676 {
25677 resultobj = SWIG_From_int((int)(result));
25678 }
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25686 PyObject *resultobj;
25687 int arg1 ;
25688 int result;
25689 PyObject * obj0 = 0 ;
25690 char *kwnames[] = {
25691 (char *) "winid", NULL
25692 };
25693
25694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25695 {
25696 arg1 = (int)(SWIG_As_int(obj0));
25697 if (SWIG_arg_fail(1)) SWIG_fail;
25698 }
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = (int)wxWindow::PrevControlId(arg1);
25702
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 {
25707 resultobj = SWIG_From_int((int)(result));
25708 }
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25716 PyObject *resultobj;
25717 wxWindow *arg1 = (wxWindow *) 0 ;
25718 wxSize *arg2 = 0 ;
25719 wxSize temp2 ;
25720 PyObject * obj0 = 0 ;
25721 PyObject * obj1 = 0 ;
25722 char *kwnames[] = {
25723 (char *) "self",(char *) "size", NULL
25724 };
25725
25726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25728 if (SWIG_arg_fail(1)) SWIG_fail;
25729 {
25730 arg2 = &temp2;
25731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25732 }
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 (arg1)->SetSize((wxSize const &)*arg2);
25736
25737 wxPyEndAllowThreads(__tstate);
25738 if (PyErr_Occurred()) SWIG_fail;
25739 }
25740 Py_INCREF(Py_None); resultobj = Py_None;
25741 return resultobj;
25742 fail:
25743 return NULL;
25744 }
25745
25746
25747 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25748 PyObject *resultobj;
25749 wxWindow *arg1 = (wxWindow *) 0 ;
25750 int arg2 ;
25751 int arg3 ;
25752 int arg4 ;
25753 int arg5 ;
25754 int arg6 = (int) wxSIZE_AUTO ;
25755 PyObject * obj0 = 0 ;
25756 PyObject * obj1 = 0 ;
25757 PyObject * obj2 = 0 ;
25758 PyObject * obj3 = 0 ;
25759 PyObject * obj4 = 0 ;
25760 PyObject * obj5 = 0 ;
25761 char *kwnames[] = {
25762 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25763 };
25764
25765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25767 if (SWIG_arg_fail(1)) SWIG_fail;
25768 {
25769 arg2 = (int)(SWIG_As_int(obj1));
25770 if (SWIG_arg_fail(2)) SWIG_fail;
25771 }
25772 {
25773 arg3 = (int)(SWIG_As_int(obj2));
25774 if (SWIG_arg_fail(3)) SWIG_fail;
25775 }
25776 {
25777 arg4 = (int)(SWIG_As_int(obj3));
25778 if (SWIG_arg_fail(4)) SWIG_fail;
25779 }
25780 {
25781 arg5 = (int)(SWIG_As_int(obj4));
25782 if (SWIG_arg_fail(5)) SWIG_fail;
25783 }
25784 if (obj5) {
25785 {
25786 arg6 = (int)(SWIG_As_int(obj5));
25787 if (SWIG_arg_fail(6)) SWIG_fail;
25788 }
25789 }
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25793
25794 wxPyEndAllowThreads(__tstate);
25795 if (PyErr_Occurred()) SWIG_fail;
25796 }
25797 Py_INCREF(Py_None); resultobj = Py_None;
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj;
25806 wxWindow *arg1 = (wxWindow *) 0 ;
25807 wxRect *arg2 = 0 ;
25808 int arg3 = (int) wxSIZE_AUTO ;
25809 wxRect temp2 ;
25810 PyObject * obj0 = 0 ;
25811 PyObject * obj1 = 0 ;
25812 PyObject * obj2 = 0 ;
25813 char *kwnames[] = {
25814 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25815 };
25816
25817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25819 if (SWIG_arg_fail(1)) SWIG_fail;
25820 {
25821 arg2 = &temp2;
25822 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25823 }
25824 if (obj2) {
25825 {
25826 arg3 = (int)(SWIG_As_int(obj2));
25827 if (SWIG_arg_fail(3)) SWIG_fail;
25828 }
25829 }
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25833
25834 wxPyEndAllowThreads(__tstate);
25835 if (PyErr_Occurred()) SWIG_fail;
25836 }
25837 Py_INCREF(Py_None); resultobj = Py_None;
25838 return resultobj;
25839 fail:
25840 return NULL;
25841 }
25842
25843
25844 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25845 PyObject *resultobj;
25846 wxWindow *arg1 = (wxWindow *) 0 ;
25847 int arg2 ;
25848 int arg3 ;
25849 PyObject * obj0 = 0 ;
25850 PyObject * obj1 = 0 ;
25851 PyObject * obj2 = 0 ;
25852 char *kwnames[] = {
25853 (char *) "self",(char *) "width",(char *) "height", NULL
25854 };
25855
25856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25858 if (SWIG_arg_fail(1)) SWIG_fail;
25859 {
25860 arg2 = (int)(SWIG_As_int(obj1));
25861 if (SWIG_arg_fail(2)) SWIG_fail;
25862 }
25863 {
25864 arg3 = (int)(SWIG_As_int(obj2));
25865 if (SWIG_arg_fail(3)) SWIG_fail;
25866 }
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 (arg1)->SetSize(arg2,arg3);
25870
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 Py_INCREF(Py_None); resultobj = Py_None;
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj;
25883 wxWindow *arg1 = (wxWindow *) 0 ;
25884 wxPoint *arg2 = 0 ;
25885 int arg3 = (int) wxSIZE_USE_EXISTING ;
25886 wxPoint temp2 ;
25887 PyObject * obj0 = 0 ;
25888 PyObject * obj1 = 0 ;
25889 PyObject * obj2 = 0 ;
25890 char *kwnames[] = {
25891 (char *) "self",(char *) "pt",(char *) "flags", NULL
25892 };
25893
25894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25896 if (SWIG_arg_fail(1)) SWIG_fail;
25897 {
25898 arg2 = &temp2;
25899 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25900 }
25901 if (obj2) {
25902 {
25903 arg3 = (int)(SWIG_As_int(obj2));
25904 if (SWIG_arg_fail(3)) SWIG_fail;
25905 }
25906 }
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 (arg1)->Move((wxPoint const &)*arg2,arg3);
25910
25911 wxPyEndAllowThreads(__tstate);
25912 if (PyErr_Occurred()) SWIG_fail;
25913 }
25914 Py_INCREF(Py_None); resultobj = Py_None;
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxWindow *arg1 = (wxWindow *) 0 ;
25924 int arg2 ;
25925 int arg3 ;
25926 int arg4 = (int) wxSIZE_USE_EXISTING ;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 PyObject * obj2 = 0 ;
25930 PyObject * obj3 = 0 ;
25931 char *kwnames[] = {
25932 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25933 };
25934
25935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(1)) SWIG_fail;
25938 {
25939 arg2 = (int)(SWIG_As_int(obj1));
25940 if (SWIG_arg_fail(2)) SWIG_fail;
25941 }
25942 {
25943 arg3 = (int)(SWIG_As_int(obj2));
25944 if (SWIG_arg_fail(3)) SWIG_fail;
25945 }
25946 if (obj3) {
25947 {
25948 arg4 = (int)(SWIG_As_int(obj3));
25949 if (SWIG_arg_fail(4)) SWIG_fail;
25950 }
25951 }
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 (arg1)->Move(arg2,arg3,arg4);
25955
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 Py_INCREF(Py_None); resultobj = Py_None;
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25967 PyObject *resultobj;
25968 wxWindow *arg1 = (wxWindow *) 0 ;
25969 wxSize const &arg2_defvalue = wxDefaultSize ;
25970 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25971 wxSize temp2 ;
25972 PyObject * obj0 = 0 ;
25973 PyObject * obj1 = 0 ;
25974 char *kwnames[] = {
25975 (char *) "self",(char *) "size", NULL
25976 };
25977
25978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25980 if (SWIG_arg_fail(1)) SWIG_fail;
25981 if (obj1) {
25982 {
25983 arg2 = &temp2;
25984 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25985 }
25986 }
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25990
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 Py_INCREF(Py_None); resultobj = Py_None;
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj;
26003 wxWindow *arg1 = (wxWindow *) 0 ;
26004 PyObject * obj0 = 0 ;
26005 char *kwnames[] = {
26006 (char *) "self", NULL
26007 };
26008
26009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26011 if (SWIG_arg_fail(1)) SWIG_fail;
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 (arg1)->Raise();
26015
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 Py_INCREF(Py_None); resultobj = Py_None;
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26027 PyObject *resultobj;
26028 wxWindow *arg1 = (wxWindow *) 0 ;
26029 PyObject * obj0 = 0 ;
26030 char *kwnames[] = {
26031 (char *) "self", NULL
26032 };
26033
26034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26036 if (SWIG_arg_fail(1)) SWIG_fail;
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 (arg1)->Lower();
26040
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 Py_INCREF(Py_None); resultobj = Py_None;
26045 return resultobj;
26046 fail:
26047 return NULL;
26048 }
26049
26050
26051 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26052 PyObject *resultobj;
26053 wxWindow *arg1 = (wxWindow *) 0 ;
26054 wxSize *arg2 = 0 ;
26055 wxSize temp2 ;
26056 PyObject * obj0 = 0 ;
26057 PyObject * obj1 = 0 ;
26058 char *kwnames[] = {
26059 (char *) "self",(char *) "size", NULL
26060 };
26061
26062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26064 if (SWIG_arg_fail(1)) SWIG_fail;
26065 {
26066 arg2 = &temp2;
26067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26068 }
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 (arg1)->SetClientSize((wxSize const &)*arg2);
26072
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 Py_INCREF(Py_None); resultobj = Py_None;
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj;
26085 wxWindow *arg1 = (wxWindow *) 0 ;
26086 int arg2 ;
26087 int arg3 ;
26088 PyObject * obj0 = 0 ;
26089 PyObject * obj1 = 0 ;
26090 PyObject * obj2 = 0 ;
26091 char *kwnames[] = {
26092 (char *) "self",(char *) "width",(char *) "height", NULL
26093 };
26094
26095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26097 if (SWIG_arg_fail(1)) SWIG_fail;
26098 {
26099 arg2 = (int)(SWIG_As_int(obj1));
26100 if (SWIG_arg_fail(2)) SWIG_fail;
26101 }
26102 {
26103 arg3 = (int)(SWIG_As_int(obj2));
26104 if (SWIG_arg_fail(3)) SWIG_fail;
26105 }
26106 {
26107 PyThreadState* __tstate = wxPyBeginAllowThreads();
26108 (arg1)->SetClientSize(arg2,arg3);
26109
26110 wxPyEndAllowThreads(__tstate);
26111 if (PyErr_Occurred()) SWIG_fail;
26112 }
26113 Py_INCREF(Py_None); resultobj = Py_None;
26114 return resultobj;
26115 fail:
26116 return NULL;
26117 }
26118
26119
26120 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26121 PyObject *resultobj;
26122 wxWindow *arg1 = (wxWindow *) 0 ;
26123 wxRect *arg2 = 0 ;
26124 wxRect temp2 ;
26125 PyObject * obj0 = 0 ;
26126 PyObject * obj1 = 0 ;
26127 char *kwnames[] = {
26128 (char *) "self",(char *) "rect", NULL
26129 };
26130
26131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26133 if (SWIG_arg_fail(1)) SWIG_fail;
26134 {
26135 arg2 = &temp2;
26136 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26137 }
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 (arg1)->SetClientSize((wxRect const &)*arg2);
26141
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 Py_INCREF(Py_None); resultobj = Py_None;
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26153 PyObject *resultobj;
26154 wxWindow *arg1 = (wxWindow *) 0 ;
26155 wxPoint result;
26156 PyObject * obj0 = 0 ;
26157 char *kwnames[] = {
26158 (char *) "self", NULL
26159 };
26160
26161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26163 if (SWIG_arg_fail(1)) SWIG_fail;
26164 {
26165 PyThreadState* __tstate = wxPyBeginAllowThreads();
26166 result = (arg1)->GetPosition();
26167
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 {
26172 wxPoint * resultptr;
26173 resultptr = new wxPoint((wxPoint &)(result));
26174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26175 }
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26183 PyObject *resultobj;
26184 wxWindow *arg1 = (wxWindow *) 0 ;
26185 int *arg2 = (int *) 0 ;
26186 int *arg3 = (int *) 0 ;
26187 int temp2 ;
26188 int res2 = 0 ;
26189 int temp3 ;
26190 int res3 = 0 ;
26191 PyObject * obj0 = 0 ;
26192 char *kwnames[] = {
26193 (char *) "self", NULL
26194 };
26195
26196 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26197 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26200 if (SWIG_arg_fail(1)) SWIG_fail;
26201 {
26202 PyThreadState* __tstate = wxPyBeginAllowThreads();
26203 (arg1)->GetPosition(arg2,arg3);
26204
26205 wxPyEndAllowThreads(__tstate);
26206 if (PyErr_Occurred()) SWIG_fail;
26207 }
26208 Py_INCREF(Py_None); resultobj = Py_None;
26209 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26210 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26211 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26212 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj;
26221 wxWindow *arg1 = (wxWindow *) 0 ;
26222 wxSize result;
26223 PyObject * obj0 = 0 ;
26224 char *kwnames[] = {
26225 (char *) "self", NULL
26226 };
26227
26228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = ((wxWindow const *)arg1)->GetSize();
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 wxSize * resultptr;
26240 resultptr = new wxSize((wxSize &)(result));
26241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxWindow *arg1 = (wxWindow *) 0 ;
26252 int *arg2 = (int *) 0 ;
26253 int *arg3 = (int *) 0 ;
26254 int temp2 ;
26255 int res2 = 0 ;
26256 int temp3 ;
26257 int res3 = 0 ;
26258 PyObject * obj0 = 0 ;
26259 char *kwnames[] = {
26260 (char *) "self", NULL
26261 };
26262
26263 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26264 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26267 if (SWIG_arg_fail(1)) SWIG_fail;
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26271
26272 wxPyEndAllowThreads(__tstate);
26273 if (PyErr_Occurred()) SWIG_fail;
26274 }
26275 Py_INCREF(Py_None); resultobj = Py_None;
26276 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26277 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26278 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26279 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26287 PyObject *resultobj;
26288 wxWindow *arg1 = (wxWindow *) 0 ;
26289 wxRect result;
26290 PyObject * obj0 = 0 ;
26291 char *kwnames[] = {
26292 (char *) "self", NULL
26293 };
26294
26295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26297 if (SWIG_arg_fail(1)) SWIG_fail;
26298 {
26299 PyThreadState* __tstate = wxPyBeginAllowThreads();
26300 result = ((wxWindow const *)arg1)->GetRect();
26301
26302 wxPyEndAllowThreads(__tstate);
26303 if (PyErr_Occurred()) SWIG_fail;
26304 }
26305 {
26306 wxRect * resultptr;
26307 resultptr = new wxRect((wxRect &)(result));
26308 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26309 }
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj;
26318 wxWindow *arg1 = (wxWindow *) 0 ;
26319 wxSize result;
26320 PyObject * obj0 = 0 ;
26321 char *kwnames[] = {
26322 (char *) "self", NULL
26323 };
26324
26325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26327 if (SWIG_arg_fail(1)) SWIG_fail;
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 result = ((wxWindow const *)arg1)->GetClientSize();
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 {
26336 wxSize * resultptr;
26337 resultptr = new wxSize((wxSize &)(result));
26338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26339 }
26340 return resultobj;
26341 fail:
26342 return NULL;
26343 }
26344
26345
26346 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26347 PyObject *resultobj;
26348 wxWindow *arg1 = (wxWindow *) 0 ;
26349 int *arg2 = (int *) 0 ;
26350 int *arg3 = (int *) 0 ;
26351 int temp2 ;
26352 int res2 = 0 ;
26353 int temp3 ;
26354 int res3 = 0 ;
26355 PyObject * obj0 = 0 ;
26356 char *kwnames[] = {
26357 (char *) "self", NULL
26358 };
26359
26360 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26361 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26364 if (SWIG_arg_fail(1)) SWIG_fail;
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26368
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 Py_INCREF(Py_None); resultobj = Py_None;
26373 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26374 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26375 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26376 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26377 return resultobj;
26378 fail:
26379 return NULL;
26380 }
26381
26382
26383 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26384 PyObject *resultobj;
26385 wxWindow *arg1 = (wxWindow *) 0 ;
26386 wxPoint result;
26387 PyObject * obj0 = 0 ;
26388 char *kwnames[] = {
26389 (char *) "self", NULL
26390 };
26391
26392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26394 if (SWIG_arg_fail(1)) SWIG_fail;
26395 {
26396 PyThreadState* __tstate = wxPyBeginAllowThreads();
26397 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26398
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 {
26403 wxPoint * resultptr;
26404 resultptr = new wxPoint((wxPoint &)(result));
26405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26406 }
26407 return resultobj;
26408 fail:
26409 return NULL;
26410 }
26411
26412
26413 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26414 PyObject *resultobj;
26415 wxWindow *arg1 = (wxWindow *) 0 ;
26416 wxRect result;
26417 PyObject * obj0 = 0 ;
26418 char *kwnames[] = {
26419 (char *) "self", NULL
26420 };
26421
26422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26424 if (SWIG_arg_fail(1)) SWIG_fail;
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 result = ((wxWindow const *)arg1)->GetClientRect();
26428
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 {
26433 wxRect * resultptr;
26434 resultptr = new wxRect((wxRect &)(result));
26435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26436 }
26437 return resultobj;
26438 fail:
26439 return NULL;
26440 }
26441
26442
26443 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj;
26445 wxWindow *arg1 = (wxWindow *) 0 ;
26446 wxSize result;
26447 PyObject * obj0 = 0 ;
26448 char *kwnames[] = {
26449 (char *) "self", NULL
26450 };
26451
26452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26454 if (SWIG_arg_fail(1)) SWIG_fail;
26455 {
26456 PyThreadState* __tstate = wxPyBeginAllowThreads();
26457 result = ((wxWindow const *)arg1)->GetBestSize();
26458
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 {
26463 wxSize * resultptr;
26464 resultptr = new wxSize((wxSize &)(result));
26465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26466 }
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj;
26475 wxWindow *arg1 = (wxWindow *) 0 ;
26476 int *arg2 = (int *) 0 ;
26477 int *arg3 = (int *) 0 ;
26478 int temp2 ;
26479 int res2 = 0 ;
26480 int temp3 ;
26481 int res3 = 0 ;
26482 PyObject * obj0 = 0 ;
26483 char *kwnames[] = {
26484 (char *) "self", NULL
26485 };
26486
26487 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26488 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26491 if (SWIG_arg_fail(1)) SWIG_fail;
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26495
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 Py_INCREF(Py_None); resultobj = Py_None;
26500 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26501 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26502 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26503 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26511 PyObject *resultobj;
26512 wxWindow *arg1 = (wxWindow *) 0 ;
26513 PyObject * obj0 = 0 ;
26514 char *kwnames[] = {
26515 (char *) "self", NULL
26516 };
26517
26518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26520 if (SWIG_arg_fail(1)) SWIG_fail;
26521 {
26522 PyThreadState* __tstate = wxPyBeginAllowThreads();
26523 (arg1)->InvalidateBestSize();
26524
26525 wxPyEndAllowThreads(__tstate);
26526 if (PyErr_Occurred()) SWIG_fail;
26527 }
26528 Py_INCREF(Py_None); resultobj = Py_None;
26529 return resultobj;
26530 fail:
26531 return NULL;
26532 }
26533
26534
26535 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26536 PyObject *resultobj;
26537 wxWindow *arg1 = (wxWindow *) 0 ;
26538 wxSize result;
26539 PyObject * obj0 = 0 ;
26540 char *kwnames[] = {
26541 (char *) "self", NULL
26542 };
26543
26544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26546 if (SWIG_arg_fail(1)) SWIG_fail;
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26550
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 {
26555 wxSize * resultptr;
26556 resultptr = new wxSize((wxSize &)(result));
26557 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26558 }
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26566 PyObject *resultobj;
26567 wxWindow *arg1 = (wxWindow *) 0 ;
26568 wxSize result;
26569 PyObject * obj0 = 0 ;
26570 char *kwnames[] = {
26571 (char *) "self", NULL
26572 };
26573
26574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26576 if (SWIG_arg_fail(1)) SWIG_fail;
26577 {
26578 PyThreadState* __tstate = wxPyBeginAllowThreads();
26579 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26580
26581 wxPyEndAllowThreads(__tstate);
26582 if (PyErr_Occurred()) SWIG_fail;
26583 }
26584 {
26585 wxSize * resultptr;
26586 resultptr = new wxSize((wxSize &)(result));
26587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26588 }
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj;
26597 wxWindow *arg1 = (wxWindow *) 0 ;
26598 int arg2 = (int) wxBOTH ;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 char *kwnames[] = {
26602 (char *) "self",(char *) "direction", NULL
26603 };
26604
26605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26607 if (SWIG_arg_fail(1)) SWIG_fail;
26608 if (obj1) {
26609 {
26610 arg2 = (int)(SWIG_As_int(obj1));
26611 if (SWIG_arg_fail(2)) SWIG_fail;
26612 }
26613 }
26614 {
26615 PyThreadState* __tstate = wxPyBeginAllowThreads();
26616 (arg1)->Center(arg2);
26617
26618 wxPyEndAllowThreads(__tstate);
26619 if (PyErr_Occurred()) SWIG_fail;
26620 }
26621 Py_INCREF(Py_None); resultobj = Py_None;
26622 return resultobj;
26623 fail:
26624 return NULL;
26625 }
26626
26627
26628 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26629 PyObject *resultobj;
26630 wxWindow *arg1 = (wxWindow *) 0 ;
26631 int arg2 = (int) wxBOTH ;
26632 PyObject * obj0 = 0 ;
26633 PyObject * obj1 = 0 ;
26634 char *kwnames[] = {
26635 (char *) "self",(char *) "dir", NULL
26636 };
26637
26638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26640 if (SWIG_arg_fail(1)) SWIG_fail;
26641 if (obj1) {
26642 {
26643 arg2 = (int)(SWIG_As_int(obj1));
26644 if (SWIG_arg_fail(2)) SWIG_fail;
26645 }
26646 }
26647 {
26648 PyThreadState* __tstate = wxPyBeginAllowThreads();
26649 (arg1)->CenterOnScreen(arg2);
26650
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 Py_INCREF(Py_None); resultobj = Py_None;
26655 return resultobj;
26656 fail:
26657 return NULL;
26658 }
26659
26660
26661 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26662 PyObject *resultobj;
26663 wxWindow *arg1 = (wxWindow *) 0 ;
26664 int arg2 = (int) wxBOTH ;
26665 PyObject * obj0 = 0 ;
26666 PyObject * obj1 = 0 ;
26667 char *kwnames[] = {
26668 (char *) "self",(char *) "dir", NULL
26669 };
26670
26671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26673 if (SWIG_arg_fail(1)) SWIG_fail;
26674 if (obj1) {
26675 {
26676 arg2 = (int)(SWIG_As_int(obj1));
26677 if (SWIG_arg_fail(2)) SWIG_fail;
26678 }
26679 }
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 (arg1)->CenterOnParent(arg2);
26683
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 Py_INCREF(Py_None); resultobj = Py_None;
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26695 PyObject *resultobj;
26696 wxWindow *arg1 = (wxWindow *) 0 ;
26697 PyObject * obj0 = 0 ;
26698 char *kwnames[] = {
26699 (char *) "self", NULL
26700 };
26701
26702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26704 if (SWIG_arg_fail(1)) SWIG_fail;
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 (arg1)->Fit();
26708
26709 wxPyEndAllowThreads(__tstate);
26710 if (PyErr_Occurred()) SWIG_fail;
26711 }
26712 Py_INCREF(Py_None); resultobj = Py_None;
26713 return resultobj;
26714 fail:
26715 return NULL;
26716 }
26717
26718
26719 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 PyObject * obj0 = 0 ;
26723 char *kwnames[] = {
26724 (char *) "self", NULL
26725 };
26726
26727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26729 if (SWIG_arg_fail(1)) SWIG_fail;
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 (arg1)->FitInside();
26733
26734 wxPyEndAllowThreads(__tstate);
26735 if (PyErr_Occurred()) SWIG_fail;
26736 }
26737 Py_INCREF(Py_None); resultobj = Py_None;
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26745 PyObject *resultobj;
26746 wxWindow *arg1 = (wxWindow *) 0 ;
26747 int arg2 ;
26748 int arg3 ;
26749 int arg4 = (int) -1 ;
26750 int arg5 = (int) -1 ;
26751 int arg6 = (int) -1 ;
26752 int arg7 = (int) -1 ;
26753 PyObject * obj0 = 0 ;
26754 PyObject * obj1 = 0 ;
26755 PyObject * obj2 = 0 ;
26756 PyObject * obj3 = 0 ;
26757 PyObject * obj4 = 0 ;
26758 PyObject * obj5 = 0 ;
26759 PyObject * obj6 = 0 ;
26760 char *kwnames[] = {
26761 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26762 };
26763
26764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26766 if (SWIG_arg_fail(1)) SWIG_fail;
26767 {
26768 arg2 = (int)(SWIG_As_int(obj1));
26769 if (SWIG_arg_fail(2)) SWIG_fail;
26770 }
26771 {
26772 arg3 = (int)(SWIG_As_int(obj2));
26773 if (SWIG_arg_fail(3)) SWIG_fail;
26774 }
26775 if (obj3) {
26776 {
26777 arg4 = (int)(SWIG_As_int(obj3));
26778 if (SWIG_arg_fail(4)) SWIG_fail;
26779 }
26780 }
26781 if (obj4) {
26782 {
26783 arg5 = (int)(SWIG_As_int(obj4));
26784 if (SWIG_arg_fail(5)) SWIG_fail;
26785 }
26786 }
26787 if (obj5) {
26788 {
26789 arg6 = (int)(SWIG_As_int(obj5));
26790 if (SWIG_arg_fail(6)) SWIG_fail;
26791 }
26792 }
26793 if (obj6) {
26794 {
26795 arg7 = (int)(SWIG_As_int(obj6));
26796 if (SWIG_arg_fail(7)) SWIG_fail;
26797 }
26798 }
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26802
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 Py_INCREF(Py_None); resultobj = Py_None;
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26814 PyObject *resultobj;
26815 wxWindow *arg1 = (wxWindow *) 0 ;
26816 wxSize *arg2 = 0 ;
26817 wxSize const &arg3_defvalue = wxDefaultSize ;
26818 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26819 wxSize const &arg4_defvalue = wxDefaultSize ;
26820 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26821 wxSize temp2 ;
26822 wxSize temp3 ;
26823 wxSize temp4 ;
26824 PyObject * obj0 = 0 ;
26825 PyObject * obj1 = 0 ;
26826 PyObject * obj2 = 0 ;
26827 PyObject * obj3 = 0 ;
26828 char *kwnames[] = {
26829 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26830 };
26831
26832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26834 if (SWIG_arg_fail(1)) SWIG_fail;
26835 {
26836 arg2 = &temp2;
26837 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26838 }
26839 if (obj2) {
26840 {
26841 arg3 = &temp3;
26842 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26843 }
26844 }
26845 if (obj3) {
26846 {
26847 arg4 = &temp4;
26848 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26849 }
26850 }
26851 {
26852 PyThreadState* __tstate = wxPyBeginAllowThreads();
26853 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26854
26855 wxPyEndAllowThreads(__tstate);
26856 if (PyErr_Occurred()) SWIG_fail;
26857 }
26858 Py_INCREF(Py_None); resultobj = Py_None;
26859 return resultobj;
26860 fail:
26861 return NULL;
26862 }
26863
26864
26865 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26866 PyObject *resultobj;
26867 wxWindow *arg1 = (wxWindow *) 0 ;
26868 int arg2 ;
26869 int arg3 ;
26870 int arg4 = (int) -1 ;
26871 int arg5 = (int) -1 ;
26872 PyObject * obj0 = 0 ;
26873 PyObject * obj1 = 0 ;
26874 PyObject * obj2 = 0 ;
26875 PyObject * obj3 = 0 ;
26876 PyObject * obj4 = 0 ;
26877 char *kwnames[] = {
26878 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26879 };
26880
26881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26883 if (SWIG_arg_fail(1)) SWIG_fail;
26884 {
26885 arg2 = (int)(SWIG_As_int(obj1));
26886 if (SWIG_arg_fail(2)) SWIG_fail;
26887 }
26888 {
26889 arg3 = (int)(SWIG_As_int(obj2));
26890 if (SWIG_arg_fail(3)) SWIG_fail;
26891 }
26892 if (obj3) {
26893 {
26894 arg4 = (int)(SWIG_As_int(obj3));
26895 if (SWIG_arg_fail(4)) SWIG_fail;
26896 }
26897 }
26898 if (obj4) {
26899 {
26900 arg5 = (int)(SWIG_As_int(obj4));
26901 if (SWIG_arg_fail(5)) SWIG_fail;
26902 }
26903 }
26904 {
26905 PyThreadState* __tstate = wxPyBeginAllowThreads();
26906 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26907
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 Py_INCREF(Py_None); resultobj = Py_None;
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj;
26920 wxWindow *arg1 = (wxWindow *) 0 ;
26921 wxSize *arg2 = 0 ;
26922 wxSize const &arg3_defvalue = wxDefaultSize ;
26923 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26924 wxSize temp2 ;
26925 wxSize temp3 ;
26926 PyObject * obj0 = 0 ;
26927 PyObject * obj1 = 0 ;
26928 PyObject * obj2 = 0 ;
26929 char *kwnames[] = {
26930 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26931 };
26932
26933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26935 if (SWIG_arg_fail(1)) SWIG_fail;
26936 {
26937 arg2 = &temp2;
26938 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26939 }
26940 if (obj2) {
26941 {
26942 arg3 = &temp3;
26943 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26944 }
26945 }
26946 {
26947 PyThreadState* __tstate = wxPyBeginAllowThreads();
26948 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26949
26950 wxPyEndAllowThreads(__tstate);
26951 if (PyErr_Occurred()) SWIG_fail;
26952 }
26953 Py_INCREF(Py_None); resultobj = Py_None;
26954 return resultobj;
26955 fail:
26956 return NULL;
26957 }
26958
26959
26960 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26961 PyObject *resultobj;
26962 wxWindow *arg1 = (wxWindow *) 0 ;
26963 wxSize result;
26964 PyObject * obj0 = 0 ;
26965 char *kwnames[] = {
26966 (char *) "self", NULL
26967 };
26968
26969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26971 if (SWIG_arg_fail(1)) SWIG_fail;
26972 {
26973 PyThreadState* __tstate = wxPyBeginAllowThreads();
26974 result = ((wxWindow const *)arg1)->GetMaxSize();
26975
26976 wxPyEndAllowThreads(__tstate);
26977 if (PyErr_Occurred()) SWIG_fail;
26978 }
26979 {
26980 wxSize * resultptr;
26981 resultptr = new wxSize((wxSize &)(result));
26982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26983 }
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26991 PyObject *resultobj;
26992 wxWindow *arg1 = (wxWindow *) 0 ;
26993 wxSize result;
26994 PyObject * obj0 = 0 ;
26995 char *kwnames[] = {
26996 (char *) "self", NULL
26997 };
26998
26999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27001 if (SWIG_arg_fail(1)) SWIG_fail;
27002 {
27003 PyThreadState* __tstate = wxPyBeginAllowThreads();
27004 result = ((wxWindow const *)arg1)->GetMinSize();
27005
27006 wxPyEndAllowThreads(__tstate);
27007 if (PyErr_Occurred()) SWIG_fail;
27008 }
27009 {
27010 wxSize * resultptr;
27011 resultptr = new wxSize((wxSize &)(result));
27012 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27013 }
27014 return resultobj;
27015 fail:
27016 return NULL;
27017 }
27018
27019
27020 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27021 PyObject *resultobj;
27022 wxWindow *arg1 = (wxWindow *) 0 ;
27023 wxSize *arg2 = 0 ;
27024 wxSize temp2 ;
27025 PyObject * obj0 = 0 ;
27026 PyObject * obj1 = 0 ;
27027 char *kwnames[] = {
27028 (char *) "self",(char *) "minSize", NULL
27029 };
27030
27031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27033 if (SWIG_arg_fail(1)) SWIG_fail;
27034 {
27035 arg2 = &temp2;
27036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27037 }
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 (arg1)->SetMinSize((wxSize const &)*arg2);
27041
27042 wxPyEndAllowThreads(__tstate);
27043 if (PyErr_Occurred()) SWIG_fail;
27044 }
27045 Py_INCREF(Py_None); resultobj = Py_None;
27046 return resultobj;
27047 fail:
27048 return NULL;
27049 }
27050
27051
27052 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27053 PyObject *resultobj;
27054 wxWindow *arg1 = (wxWindow *) 0 ;
27055 wxSize *arg2 = 0 ;
27056 wxSize temp2 ;
27057 PyObject * obj0 = 0 ;
27058 PyObject * obj1 = 0 ;
27059 char *kwnames[] = {
27060 (char *) "self",(char *) "maxSize", NULL
27061 };
27062
27063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27065 if (SWIG_arg_fail(1)) SWIG_fail;
27066 {
27067 arg2 = &temp2;
27068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27069 }
27070 {
27071 PyThreadState* __tstate = wxPyBeginAllowThreads();
27072 (arg1)->SetMaxSize((wxSize const &)*arg2);
27073
27074 wxPyEndAllowThreads(__tstate);
27075 if (PyErr_Occurred()) SWIG_fail;
27076 }
27077 Py_INCREF(Py_None); resultobj = Py_None;
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj;
27086 wxWindow *arg1 = (wxWindow *) 0 ;
27087 int result;
27088 PyObject * obj0 = 0 ;
27089 char *kwnames[] = {
27090 (char *) "self", NULL
27091 };
27092
27093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27095 if (SWIG_arg_fail(1)) SWIG_fail;
27096 {
27097 PyThreadState* __tstate = wxPyBeginAllowThreads();
27098 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27099
27100 wxPyEndAllowThreads(__tstate);
27101 if (PyErr_Occurred()) SWIG_fail;
27102 }
27103 {
27104 resultobj = SWIG_From_int((int)(result));
27105 }
27106 return resultobj;
27107 fail:
27108 return NULL;
27109 }
27110
27111
27112 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj;
27114 wxWindow *arg1 = (wxWindow *) 0 ;
27115 int result;
27116 PyObject * obj0 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self", NULL
27119 };
27120
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(1)) SWIG_fail;
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = SWIG_From_int((int)(result));
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxWindow *arg1 = (wxWindow *) 0 ;
27143 int result;
27144 PyObject * obj0 = 0 ;
27145 char *kwnames[] = {
27146 (char *) "self", NULL
27147 };
27148
27149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27151 if (SWIG_arg_fail(1)) SWIG_fail;
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27155
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 {
27160 resultobj = SWIG_From_int((int)(result));
27161 }
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj;
27170 wxWindow *arg1 = (wxWindow *) 0 ;
27171 int result;
27172 PyObject * obj0 = 0 ;
27173 char *kwnames[] = {
27174 (char *) "self", NULL
27175 };
27176
27177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27179 if (SWIG_arg_fail(1)) SWIG_fail;
27180 {
27181 PyThreadState* __tstate = wxPyBeginAllowThreads();
27182 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27183
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 {
27188 resultobj = SWIG_From_int((int)(result));
27189 }
27190 return resultobj;
27191 fail:
27192 return NULL;
27193 }
27194
27195
27196 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj;
27198 wxWindow *arg1 = (wxWindow *) 0 ;
27199 wxSize *arg2 = 0 ;
27200 wxSize temp2 ;
27201 PyObject * obj0 = 0 ;
27202 PyObject * obj1 = 0 ;
27203 char *kwnames[] = {
27204 (char *) "self",(char *) "size", NULL
27205 };
27206
27207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27209 if (SWIG_arg_fail(1)) SWIG_fail;
27210 {
27211 arg2 = &temp2;
27212 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27213 }
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27217
27218 wxPyEndAllowThreads(__tstate);
27219 if (PyErr_Occurred()) SWIG_fail;
27220 }
27221 Py_INCREF(Py_None); resultobj = Py_None;
27222 return resultobj;
27223 fail:
27224 return NULL;
27225 }
27226
27227
27228 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27229 PyObject *resultobj;
27230 wxWindow *arg1 = (wxWindow *) 0 ;
27231 int arg2 ;
27232 int arg3 ;
27233 PyObject * obj0 = 0 ;
27234 PyObject * obj1 = 0 ;
27235 PyObject * obj2 = 0 ;
27236 char *kwnames[] = {
27237 (char *) "self",(char *) "w",(char *) "h", NULL
27238 };
27239
27240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27242 if (SWIG_arg_fail(1)) SWIG_fail;
27243 {
27244 arg2 = (int)(SWIG_As_int(obj1));
27245 if (SWIG_arg_fail(2)) SWIG_fail;
27246 }
27247 {
27248 arg3 = (int)(SWIG_As_int(obj2));
27249 if (SWIG_arg_fail(3)) SWIG_fail;
27250 }
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->SetVirtualSize(arg2,arg3);
27254
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 Py_INCREF(Py_None); resultobj = Py_None;
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 wxSize result;
27269 PyObject * obj0 = 0 ;
27270 char *kwnames[] = {
27271 (char *) "self", NULL
27272 };
27273
27274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = ((wxWindow const *)arg1)->GetVirtualSize();
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 {
27285 wxSize * resultptr;
27286 resultptr = new wxSize((wxSize &)(result));
27287 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27288 }
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27296 PyObject *resultobj;
27297 wxWindow *arg1 = (wxWindow *) 0 ;
27298 int *arg2 = (int *) 0 ;
27299 int *arg3 = (int *) 0 ;
27300 int temp2 ;
27301 int res2 = 0 ;
27302 int temp3 ;
27303 int res3 = 0 ;
27304 PyObject * obj0 = 0 ;
27305 char *kwnames[] = {
27306 (char *) "self", NULL
27307 };
27308
27309 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27310 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27313 if (SWIG_arg_fail(1)) SWIG_fail;
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27317
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 Py_INCREF(Py_None); resultobj = Py_None;
27322 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27323 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27324 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27325 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxWindow *arg1 = (wxWindow *) 0 ;
27335 wxSize result;
27336 PyObject * obj0 = 0 ;
27337 char *kwnames[] = {
27338 (char *) "self", NULL
27339 };
27340
27341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27343 if (SWIG_arg_fail(1)) SWIG_fail;
27344 {
27345 PyThreadState* __tstate = wxPyBeginAllowThreads();
27346 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27347
27348 wxPyEndAllowThreads(__tstate);
27349 if (PyErr_Occurred()) SWIG_fail;
27350 }
27351 {
27352 wxSize * resultptr;
27353 resultptr = new wxSize((wxSize &)(result));
27354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27355 }
27356 return resultobj;
27357 fail:
27358 return NULL;
27359 }
27360
27361
27362 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27363 PyObject *resultobj;
27364 wxWindow *arg1 = (wxWindow *) 0 ;
27365 bool arg2 = (bool) true ;
27366 bool result;
27367 PyObject * obj0 = 0 ;
27368 PyObject * obj1 = 0 ;
27369 char *kwnames[] = {
27370 (char *) "self",(char *) "show", NULL
27371 };
27372
27373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27375 if (SWIG_arg_fail(1)) SWIG_fail;
27376 if (obj1) {
27377 {
27378 arg2 = (bool)(SWIG_As_bool(obj1));
27379 if (SWIG_arg_fail(2)) SWIG_fail;
27380 }
27381 }
27382 {
27383 PyThreadState* __tstate = wxPyBeginAllowThreads();
27384 result = (bool)(arg1)->Show(arg2);
27385
27386 wxPyEndAllowThreads(__tstate);
27387 if (PyErr_Occurred()) SWIG_fail;
27388 }
27389 {
27390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27391 }
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27399 PyObject *resultobj;
27400 wxWindow *arg1 = (wxWindow *) 0 ;
27401 bool result;
27402 PyObject * obj0 = 0 ;
27403 char *kwnames[] = {
27404 (char *) "self", NULL
27405 };
27406
27407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27409 if (SWIG_arg_fail(1)) SWIG_fail;
27410 {
27411 PyThreadState* __tstate = wxPyBeginAllowThreads();
27412 result = (bool)(arg1)->Hide();
27413
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 {
27418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27419 }
27420 return resultobj;
27421 fail:
27422 return NULL;
27423 }
27424
27425
27426 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27427 PyObject *resultobj;
27428 wxWindow *arg1 = (wxWindow *) 0 ;
27429 bool arg2 = (bool) true ;
27430 bool result;
27431 PyObject * obj0 = 0 ;
27432 PyObject * obj1 = 0 ;
27433 char *kwnames[] = {
27434 (char *) "self",(char *) "enable", NULL
27435 };
27436
27437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27439 if (SWIG_arg_fail(1)) SWIG_fail;
27440 if (obj1) {
27441 {
27442 arg2 = (bool)(SWIG_As_bool(obj1));
27443 if (SWIG_arg_fail(2)) SWIG_fail;
27444 }
27445 }
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = (bool)(arg1)->Enable(arg2);
27449
27450 wxPyEndAllowThreads(__tstate);
27451 if (PyErr_Occurred()) SWIG_fail;
27452 }
27453 {
27454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27455 }
27456 return resultobj;
27457 fail:
27458 return NULL;
27459 }
27460
27461
27462 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27463 PyObject *resultobj;
27464 wxWindow *arg1 = (wxWindow *) 0 ;
27465 bool result;
27466 PyObject * obj0 = 0 ;
27467 char *kwnames[] = {
27468 (char *) "self", NULL
27469 };
27470
27471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27473 if (SWIG_arg_fail(1)) SWIG_fail;
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 result = (bool)(arg1)->Disable();
27477
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 {
27482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27483 }
27484 return resultobj;
27485 fail:
27486 return NULL;
27487 }
27488
27489
27490 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27491 PyObject *resultobj;
27492 wxWindow *arg1 = (wxWindow *) 0 ;
27493 bool result;
27494 PyObject * obj0 = 0 ;
27495 char *kwnames[] = {
27496 (char *) "self", NULL
27497 };
27498
27499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27501 if (SWIG_arg_fail(1)) SWIG_fail;
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 result = (bool)((wxWindow const *)arg1)->IsShown();
27505
27506 wxPyEndAllowThreads(__tstate);
27507 if (PyErr_Occurred()) SWIG_fail;
27508 }
27509 {
27510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27511 }
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27519 PyObject *resultobj;
27520 wxWindow *arg1 = (wxWindow *) 0 ;
27521 bool result;
27522 PyObject * obj0 = 0 ;
27523 char *kwnames[] = {
27524 (char *) "self", NULL
27525 };
27526
27527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27529 if (SWIG_arg_fail(1)) SWIG_fail;
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27533
27534 wxPyEndAllowThreads(__tstate);
27535 if (PyErr_Occurred()) SWIG_fail;
27536 }
27537 {
27538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27539 }
27540 return resultobj;
27541 fail:
27542 return NULL;
27543 }
27544
27545
27546 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27547 PyObject *resultobj;
27548 wxWindow *arg1 = (wxWindow *) 0 ;
27549 long arg2 ;
27550 PyObject * obj0 = 0 ;
27551 PyObject * obj1 = 0 ;
27552 char *kwnames[] = {
27553 (char *) "self",(char *) "style", NULL
27554 };
27555
27556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27558 if (SWIG_arg_fail(1)) SWIG_fail;
27559 {
27560 arg2 = (long)(SWIG_As_long(obj1));
27561 if (SWIG_arg_fail(2)) SWIG_fail;
27562 }
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 (arg1)->SetWindowStyleFlag(arg2);
27566
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 Py_INCREF(Py_None); resultobj = Py_None;
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27578 PyObject *resultobj;
27579 wxWindow *arg1 = (wxWindow *) 0 ;
27580 long result;
27581 PyObject * obj0 = 0 ;
27582 char *kwnames[] = {
27583 (char *) "self", NULL
27584 };
27585
27586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27588 if (SWIG_arg_fail(1)) SWIG_fail;
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27592
27593 wxPyEndAllowThreads(__tstate);
27594 if (PyErr_Occurred()) SWIG_fail;
27595 }
27596 {
27597 resultobj = SWIG_From_long((long)(result));
27598 }
27599 return resultobj;
27600 fail:
27601 return NULL;
27602 }
27603
27604
27605 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27606 PyObject *resultobj;
27607 wxWindow *arg1 = (wxWindow *) 0 ;
27608 int arg2 ;
27609 bool result;
27610 PyObject * obj0 = 0 ;
27611 PyObject * obj1 = 0 ;
27612 char *kwnames[] = {
27613 (char *) "self",(char *) "flag", NULL
27614 };
27615
27616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27618 if (SWIG_arg_fail(1)) SWIG_fail;
27619 {
27620 arg2 = (int)(SWIG_As_int(obj1));
27621 if (SWIG_arg_fail(2)) SWIG_fail;
27622 }
27623 {
27624 PyThreadState* __tstate = wxPyBeginAllowThreads();
27625 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27626
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 {
27631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj;
27641 wxWindow *arg1 = (wxWindow *) 0 ;
27642 bool result;
27643 PyObject * obj0 = 0 ;
27644 char *kwnames[] = {
27645 (char *) "self", NULL
27646 };
27647
27648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27650 if (SWIG_arg_fail(1)) SWIG_fail;
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (bool)((wxWindow const *)arg1)->IsRetained();
27654
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 {
27659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27660 }
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxWindow *arg1 = (wxWindow *) 0 ;
27670 long arg2 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self",(char *) "exStyle", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(1)) SWIG_fail;
27680 {
27681 arg2 = (long)(SWIG_As_long(obj1));
27682 if (SWIG_arg_fail(2)) SWIG_fail;
27683 }
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->SetExtraStyle(arg2);
27687
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 Py_INCREF(Py_None); resultobj = Py_None;
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxWindow *arg1 = (wxWindow *) 0 ;
27701 long result;
27702 PyObject * obj0 = 0 ;
27703 char *kwnames[] = {
27704 (char *) "self", NULL
27705 };
27706
27707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27709 if (SWIG_arg_fail(1)) SWIG_fail;
27710 {
27711 PyThreadState* __tstate = wxPyBeginAllowThreads();
27712 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27713
27714 wxPyEndAllowThreads(__tstate);
27715 if (PyErr_Occurred()) SWIG_fail;
27716 }
27717 {
27718 resultobj = SWIG_From_long((long)(result));
27719 }
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27727 PyObject *resultobj;
27728 wxWindow *arg1 = (wxWindow *) 0 ;
27729 bool arg2 = (bool) true ;
27730 PyObject * obj0 = 0 ;
27731 PyObject * obj1 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "self",(char *) "modal", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27738 if (SWIG_arg_fail(1)) SWIG_fail;
27739 if (obj1) {
27740 {
27741 arg2 = (bool)(SWIG_As_bool(obj1));
27742 if (SWIG_arg_fail(2)) SWIG_fail;
27743 }
27744 }
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 (arg1)->MakeModal(arg2);
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 Py_INCREF(Py_None); resultobj = Py_None;
27753 return resultobj;
27754 fail:
27755 return NULL;
27756 }
27757
27758
27759 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27760 PyObject *resultobj;
27761 wxWindow *arg1 = (wxWindow *) 0 ;
27762 bool arg2 ;
27763 PyObject * obj0 = 0 ;
27764 PyObject * obj1 = 0 ;
27765 char *kwnames[] = {
27766 (char *) "self",(char *) "enableTheme", NULL
27767 };
27768
27769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27771 if (SWIG_arg_fail(1)) SWIG_fail;
27772 {
27773 arg2 = (bool)(SWIG_As_bool(obj1));
27774 if (SWIG_arg_fail(2)) SWIG_fail;
27775 }
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 (arg1)->SetThemeEnabled(arg2);
27779
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 Py_INCREF(Py_None); resultobj = Py_None;
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27791 PyObject *resultobj;
27792 wxWindow *arg1 = (wxWindow *) 0 ;
27793 bool result;
27794 PyObject * obj0 = 0 ;
27795 char *kwnames[] = {
27796 (char *) "self", NULL
27797 };
27798
27799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27801 if (SWIG_arg_fail(1)) SWIG_fail;
27802 {
27803 PyThreadState* __tstate = wxPyBeginAllowThreads();
27804 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27805
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 {
27810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27811 }
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27819 PyObject *resultobj;
27820 wxWindow *arg1 = (wxWindow *) 0 ;
27821 PyObject * obj0 = 0 ;
27822 char *kwnames[] = {
27823 (char *) "self", NULL
27824 };
27825
27826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27828 if (SWIG_arg_fail(1)) SWIG_fail;
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 (arg1)->SetFocus();
27832
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 Py_INCREF(Py_None); resultobj = Py_None;
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj;
27845 wxWindow *arg1 = (wxWindow *) 0 ;
27846 PyObject * obj0 = 0 ;
27847 char *kwnames[] = {
27848 (char *) "self", NULL
27849 };
27850
27851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27853 if (SWIG_arg_fail(1)) SWIG_fail;
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 (arg1)->SetFocusFromKbd();
27857
27858 wxPyEndAllowThreads(__tstate);
27859 if (PyErr_Occurred()) SWIG_fail;
27860 }
27861 Py_INCREF(Py_None); resultobj = Py_None;
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27869 PyObject *resultobj;
27870 wxWindow *result;
27871 char *kwnames[] = {
27872 NULL
27873 };
27874
27875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27876 {
27877 if (!wxPyCheckForApp()) SWIG_fail;
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 result = (wxWindow *)wxWindow::FindFocus();
27880
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 {
27885 resultobj = wxPyMake_wxObject(result, 0);
27886 }
27887 return resultobj;
27888 fail:
27889 return NULL;
27890 }
27891
27892
27893 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27894 PyObject *resultobj;
27895 wxWindow *arg1 = (wxWindow *) 0 ;
27896 bool result;
27897 PyObject * obj0 = 0 ;
27898 char *kwnames[] = {
27899 (char *) "self", NULL
27900 };
27901
27902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27904 if (SWIG_arg_fail(1)) SWIG_fail;
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27914 }
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj;
27923 wxWindow *arg1 = (wxWindow *) 0 ;
27924 bool result;
27925 PyObject * obj0 = 0 ;
27926 char *kwnames[] = {
27927 (char *) "self", NULL
27928 };
27929
27930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27932 if (SWIG_arg_fail(1)) SWIG_fail;
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27936
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27942 }
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxWindow *arg1 = (wxWindow *) 0 ;
27952 wxWindow *result;
27953 PyObject * obj0 = 0 ;
27954 char *kwnames[] = {
27955 (char *) "self", NULL
27956 };
27957
27958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27960 if (SWIG_arg_fail(1)) SWIG_fail;
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27964
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 {
27969 resultobj = wxPyMake_wxObject(result, 0);
27970 }
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj;
27979 wxWindow *arg1 = (wxWindow *) 0 ;
27980 wxWindow *arg2 = (wxWindow *) 0 ;
27981 wxWindow *result;
27982 PyObject * obj0 = 0 ;
27983 PyObject * obj1 = 0 ;
27984 char *kwnames[] = {
27985 (char *) "self",(char *) "child", NULL
27986 };
27987
27988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27990 if (SWIG_arg_fail(1)) SWIG_fail;
27991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27992 if (SWIG_arg_fail(2)) SWIG_fail;
27993 {
27994 PyThreadState* __tstate = wxPyBeginAllowThreads();
27995 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27996
27997 wxPyEndAllowThreads(__tstate);
27998 if (PyErr_Occurred()) SWIG_fail;
27999 }
28000 {
28001 resultobj = wxPyMake_wxObject(result, 0);
28002 }
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxWindow *arg1 = (wxWindow *) 0 ;
28012 wxWindow *arg2 = (wxWindow *) 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char *kwnames[] = {
28016 (char *) "self",(char *) "win", NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28021 if (SWIG_arg_fail(1)) SWIG_fail;
28022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(2)) SWIG_fail;
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 (arg1)->SetTmpDefaultItem(arg2);
28027
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 Py_INCREF(Py_None); resultobj = Py_None;
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28039 PyObject *resultobj;
28040 wxWindow *arg1 = (wxWindow *) 0 ;
28041 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28042 bool result;
28043 PyObject * obj0 = 0 ;
28044 PyObject * obj1 = 0 ;
28045 char *kwnames[] = {
28046 (char *) "self",(char *) "flags", NULL
28047 };
28048
28049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28051 if (SWIG_arg_fail(1)) SWIG_fail;
28052 if (obj1) {
28053 {
28054 arg2 = (int)(SWIG_As_int(obj1));
28055 if (SWIG_arg_fail(2)) SWIG_fail;
28056 }
28057 }
28058 {
28059 PyThreadState* __tstate = wxPyBeginAllowThreads();
28060 result = (bool)(arg1)->Navigate(arg2);
28061
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 {
28066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28067 }
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj;
28076 wxWindow *arg1 = (wxWindow *) 0 ;
28077 wxWindow *arg2 = (wxWindow *) 0 ;
28078 PyObject * obj0 = 0 ;
28079 PyObject * obj1 = 0 ;
28080 char *kwnames[] = {
28081 (char *) "self",(char *) "win", NULL
28082 };
28083
28084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28086 if (SWIG_arg_fail(1)) SWIG_fail;
28087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28088 if (SWIG_arg_fail(2)) SWIG_fail;
28089 {
28090 PyThreadState* __tstate = wxPyBeginAllowThreads();
28091 (arg1)->MoveAfterInTabOrder(arg2);
28092
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 Py_INCREF(Py_None); resultobj = Py_None;
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj;
28105 wxWindow *arg1 = (wxWindow *) 0 ;
28106 wxWindow *arg2 = (wxWindow *) 0 ;
28107 PyObject * obj0 = 0 ;
28108 PyObject * obj1 = 0 ;
28109 char *kwnames[] = {
28110 (char *) "self",(char *) "win", NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(1)) SWIG_fail;
28116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28117 if (SWIG_arg_fail(2)) SWIG_fail;
28118 {
28119 PyThreadState* __tstate = wxPyBeginAllowThreads();
28120 (arg1)->MoveBeforeInTabOrder(arg2);
28121
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 Py_INCREF(Py_None); resultobj = Py_None;
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj;
28134 wxWindow *arg1 = (wxWindow *) 0 ;
28135 PyObject *result;
28136 PyObject * obj0 = 0 ;
28137 char *kwnames[] = {
28138 (char *) "self", NULL
28139 };
28140
28141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28143 if (SWIG_arg_fail(1)) SWIG_fail;
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 result = (PyObject *)wxWindow_GetChildren(arg1);
28147
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 resultobj = result;
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28159 PyObject *resultobj;
28160 wxWindow *arg1 = (wxWindow *) 0 ;
28161 wxWindow *result;
28162 PyObject * obj0 = 0 ;
28163 char *kwnames[] = {
28164 (char *) "self", NULL
28165 };
28166
28167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28169 if (SWIG_arg_fail(1)) SWIG_fail;
28170 {
28171 PyThreadState* __tstate = wxPyBeginAllowThreads();
28172 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28173
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 {
28178 resultobj = wxPyMake_wxObject(result, 0);
28179 }
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28187 PyObject *resultobj;
28188 wxWindow *arg1 = (wxWindow *) 0 ;
28189 wxWindow *result;
28190 PyObject * obj0 = 0 ;
28191 char *kwnames[] = {
28192 (char *) "self", NULL
28193 };
28194
28195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28197 if (SWIG_arg_fail(1)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 {
28206 resultobj = wxPyMake_wxObject(result, 0);
28207 }
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj;
28216 wxWindow *arg1 = (wxWindow *) 0 ;
28217 bool result;
28218 PyObject * obj0 = 0 ;
28219 char *kwnames[] = {
28220 (char *) "self", NULL
28221 };
28222
28223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28225 if (SWIG_arg_fail(1)) SWIG_fail;
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28229
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 {
28234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28235 }
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj;
28244 wxWindow *arg1 = (wxWindow *) 0 ;
28245 wxWindow *arg2 = (wxWindow *) 0 ;
28246 bool result;
28247 PyObject * obj0 = 0 ;
28248 PyObject * obj1 = 0 ;
28249 char *kwnames[] = {
28250 (char *) "self",(char *) "newParent", NULL
28251 };
28252
28253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28255 if (SWIG_arg_fail(1)) SWIG_fail;
28256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28257 if (SWIG_arg_fail(2)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = (bool)(arg1)->Reparent(arg2);
28261
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj;
28276 wxWindow *arg1 = (wxWindow *) 0 ;
28277 wxWindow *arg2 = (wxWindow *) 0 ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char *kwnames[] = {
28281 (char *) "self",(char *) "child", NULL
28282 };
28283
28284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28286 if (SWIG_arg_fail(1)) SWIG_fail;
28287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28288 if (SWIG_arg_fail(2)) SWIG_fail;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 (arg1)->AddChild(arg2);
28292
28293 wxPyEndAllowThreads(__tstate);
28294 if (PyErr_Occurred()) SWIG_fail;
28295 }
28296 Py_INCREF(Py_None); resultobj = Py_None;
28297 return resultobj;
28298 fail:
28299 return NULL;
28300 }
28301
28302
28303 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28304 PyObject *resultobj;
28305 wxWindow *arg1 = (wxWindow *) 0 ;
28306 wxWindow *arg2 = (wxWindow *) 0 ;
28307 PyObject * obj0 = 0 ;
28308 PyObject * obj1 = 0 ;
28309 char *kwnames[] = {
28310 (char *) "self",(char *) "child", NULL
28311 };
28312
28313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28315 if (SWIG_arg_fail(1)) SWIG_fail;
28316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28317 if (SWIG_arg_fail(2)) SWIG_fail;
28318 {
28319 PyThreadState* __tstate = wxPyBeginAllowThreads();
28320 (arg1)->RemoveChild(arg2);
28321
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 Py_INCREF(Py_None); resultobj = Py_None;
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj;
28334 wxWindow *arg1 = (wxWindow *) 0 ;
28335 long arg2 ;
28336 wxWindow *result;
28337 PyObject * obj0 = 0 ;
28338 PyObject * obj1 = 0 ;
28339 char *kwnames[] = {
28340 (char *) "self",(char *) "winid", NULL
28341 };
28342
28343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28345 if (SWIG_arg_fail(1)) SWIG_fail;
28346 {
28347 arg2 = (long)(SWIG_As_long(obj1));
28348 if (SWIG_arg_fail(2)) SWIG_fail;
28349 }
28350 {
28351 PyThreadState* __tstate = wxPyBeginAllowThreads();
28352 result = (wxWindow *)(arg1)->FindWindow(arg2);
28353
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 {
28358 resultobj = wxPyMake_wxObject(result, 0);
28359 }
28360 return resultobj;
28361 fail:
28362 return NULL;
28363 }
28364
28365
28366 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28367 PyObject *resultobj;
28368 wxWindow *arg1 = (wxWindow *) 0 ;
28369 wxString *arg2 = 0 ;
28370 wxWindow *result;
28371 bool temp2 = false ;
28372 PyObject * obj0 = 0 ;
28373 PyObject * obj1 = 0 ;
28374 char *kwnames[] = {
28375 (char *) "self",(char *) "name", NULL
28376 };
28377
28378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28380 if (SWIG_arg_fail(1)) SWIG_fail;
28381 {
28382 arg2 = wxString_in_helper(obj1);
28383 if (arg2 == NULL) SWIG_fail;
28384 temp2 = true;
28385 }
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28389
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 {
28394 resultobj = wxPyMake_wxObject(result, 0);
28395 }
28396 {
28397 if (temp2)
28398 delete arg2;
28399 }
28400 return resultobj;
28401 fail:
28402 {
28403 if (temp2)
28404 delete arg2;
28405 }
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxWindow *arg1 = (wxWindow *) 0 ;
28413 wxEvtHandler *result;
28414 PyObject * obj0 = 0 ;
28415 char *kwnames[] = {
28416 (char *) "self", NULL
28417 };
28418
28419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28421 if (SWIG_arg_fail(1)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 {
28430 resultobj = wxPyMake_wxObject(result, 0);
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28439 PyObject *resultobj;
28440 wxWindow *arg1 = (wxWindow *) 0 ;
28441 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28442 PyObject * obj0 = 0 ;
28443 PyObject * obj1 = 0 ;
28444 char *kwnames[] = {
28445 (char *) "self",(char *) "handler", NULL
28446 };
28447
28448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28450 if (SWIG_arg_fail(1)) SWIG_fail;
28451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28452 if (SWIG_arg_fail(2)) SWIG_fail;
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 (arg1)->SetEventHandler(arg2);
28456
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 Py_INCREF(Py_None); resultobj = Py_None;
28461 return resultobj;
28462 fail:
28463 return NULL;
28464 }
28465
28466
28467 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28468 PyObject *resultobj;
28469 wxWindow *arg1 = (wxWindow *) 0 ;
28470 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28471 PyObject * obj0 = 0 ;
28472 PyObject * obj1 = 0 ;
28473 char *kwnames[] = {
28474 (char *) "self",(char *) "handler", NULL
28475 };
28476
28477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28479 if (SWIG_arg_fail(1)) SWIG_fail;
28480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28481 if (SWIG_arg_fail(2)) SWIG_fail;
28482 {
28483 PyThreadState* __tstate = wxPyBeginAllowThreads();
28484 (arg1)->PushEventHandler(arg2);
28485
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 Py_INCREF(Py_None); resultobj = Py_None;
28490 return resultobj;
28491 fail:
28492 return NULL;
28493 }
28494
28495
28496 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28497 PyObject *resultobj;
28498 wxWindow *arg1 = (wxWindow *) 0 ;
28499 bool arg2 = (bool) false ;
28500 wxEvtHandler *result;
28501 PyObject * obj0 = 0 ;
28502 PyObject * obj1 = 0 ;
28503 char *kwnames[] = {
28504 (char *) "self",(char *) "deleteHandler", NULL
28505 };
28506
28507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28509 if (SWIG_arg_fail(1)) SWIG_fail;
28510 if (obj1) {
28511 {
28512 arg2 = (bool)(SWIG_As_bool(obj1));
28513 if (SWIG_arg_fail(2)) SWIG_fail;
28514 }
28515 }
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28519
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 {
28524 resultobj = wxPyMake_wxObject(result, 0);
28525 }
28526 return resultobj;
28527 fail:
28528 return NULL;
28529 }
28530
28531
28532 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28533 PyObject *resultobj;
28534 wxWindow *arg1 = (wxWindow *) 0 ;
28535 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28536 bool result;
28537 PyObject * obj0 = 0 ;
28538 PyObject * obj1 = 0 ;
28539 char *kwnames[] = {
28540 (char *) "self",(char *) "handler", NULL
28541 };
28542
28543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28545 if (SWIG_arg_fail(1)) SWIG_fail;
28546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28547 if (SWIG_arg_fail(2)) SWIG_fail;
28548 {
28549 PyThreadState* __tstate = wxPyBeginAllowThreads();
28550 result = (bool)(arg1)->RemoveEventHandler(arg2);
28551
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 {
28556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28557 }
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28565 PyObject *resultobj;
28566 wxWindow *arg1 = (wxWindow *) 0 ;
28567 wxValidator *arg2 = 0 ;
28568 PyObject * obj0 = 0 ;
28569 PyObject * obj1 = 0 ;
28570 char *kwnames[] = {
28571 (char *) "self",(char *) "validator", NULL
28572 };
28573
28574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28576 if (SWIG_arg_fail(1)) SWIG_fail;
28577 {
28578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28579 if (SWIG_arg_fail(2)) SWIG_fail;
28580 if (arg2 == NULL) {
28581 SWIG_null_ref("wxValidator");
28582 }
28583 if (SWIG_arg_fail(2)) SWIG_fail;
28584 }
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 (arg1)->SetValidator((wxValidator const &)*arg2);
28588
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 Py_INCREF(Py_None); resultobj = Py_None;
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28600 PyObject *resultobj;
28601 wxWindow *arg1 = (wxWindow *) 0 ;
28602 wxValidator *result;
28603 PyObject * obj0 = 0 ;
28604 char *kwnames[] = {
28605 (char *) "self", NULL
28606 };
28607
28608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28610 if (SWIG_arg_fail(1)) SWIG_fail;
28611 {
28612 PyThreadState* __tstate = wxPyBeginAllowThreads();
28613 result = (wxValidator *)(arg1)->GetValidator();
28614
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 {
28619 resultobj = wxPyMake_wxObject(result, 0);
28620 }
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28628 PyObject *resultobj;
28629 wxWindow *arg1 = (wxWindow *) 0 ;
28630 bool result;
28631 PyObject * obj0 = 0 ;
28632 char *kwnames[] = {
28633 (char *) "self", NULL
28634 };
28635
28636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28638 if (SWIG_arg_fail(1)) SWIG_fail;
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 result = (bool)(arg1)->Validate();
28642
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 {
28647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28648 }
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj;
28657 wxWindow *arg1 = (wxWindow *) 0 ;
28658 bool result;
28659 PyObject * obj0 = 0 ;
28660 char *kwnames[] = {
28661 (char *) "self", NULL
28662 };
28663
28664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28666 if (SWIG_arg_fail(1)) SWIG_fail;
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = (bool)(arg1)->TransferDataToWindow();
28670
28671 wxPyEndAllowThreads(__tstate);
28672 if (PyErr_Occurred()) SWIG_fail;
28673 }
28674 {
28675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28676 }
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28684 PyObject *resultobj;
28685 wxWindow *arg1 = (wxWindow *) 0 ;
28686 bool result;
28687 PyObject * obj0 = 0 ;
28688 char *kwnames[] = {
28689 (char *) "self", NULL
28690 };
28691
28692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28694 if (SWIG_arg_fail(1)) SWIG_fail;
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 result = (bool)(arg1)->TransferDataFromWindow();
28698
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 {
28703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28704 }
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28712 PyObject *resultobj;
28713 wxWindow *arg1 = (wxWindow *) 0 ;
28714 PyObject * obj0 = 0 ;
28715 char *kwnames[] = {
28716 (char *) "self", NULL
28717 };
28718
28719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28721 if (SWIG_arg_fail(1)) SWIG_fail;
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 (arg1)->InitDialog();
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 Py_INCREF(Py_None); resultobj = Py_None;
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28737 PyObject *resultobj;
28738 wxWindow *arg1 = (wxWindow *) 0 ;
28739 wxAcceleratorTable *arg2 = 0 ;
28740 PyObject * obj0 = 0 ;
28741 PyObject * obj1 = 0 ;
28742 char *kwnames[] = {
28743 (char *) "self",(char *) "accel", NULL
28744 };
28745
28746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28748 if (SWIG_arg_fail(1)) SWIG_fail;
28749 {
28750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28751 if (SWIG_arg_fail(2)) SWIG_fail;
28752 if (arg2 == NULL) {
28753 SWIG_null_ref("wxAcceleratorTable");
28754 }
28755 if (SWIG_arg_fail(2)) SWIG_fail;
28756 }
28757 {
28758 PyThreadState* __tstate = wxPyBeginAllowThreads();
28759 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28760
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 Py_INCREF(Py_None); resultobj = Py_None;
28765 return resultobj;
28766 fail:
28767 return NULL;
28768 }
28769
28770
28771 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28772 PyObject *resultobj;
28773 wxWindow *arg1 = (wxWindow *) 0 ;
28774 wxAcceleratorTable *result;
28775 PyObject * obj0 = 0 ;
28776 char *kwnames[] = {
28777 (char *) "self", NULL
28778 };
28779
28780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28782 if (SWIG_arg_fail(1)) SWIG_fail;
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28786
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28798 PyObject *resultobj;
28799 wxWindow *arg1 = (wxWindow *) 0 ;
28800 int arg2 ;
28801 int arg3 ;
28802 int arg4 ;
28803 bool result;
28804 PyObject * obj0 = 0 ;
28805 PyObject * obj1 = 0 ;
28806 PyObject * obj2 = 0 ;
28807 PyObject * obj3 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 {
28816 arg2 = (int)(SWIG_As_int(obj1));
28817 if (SWIG_arg_fail(2)) SWIG_fail;
28818 }
28819 {
28820 arg3 = (int)(SWIG_As_int(obj2));
28821 if (SWIG_arg_fail(3)) SWIG_fail;
28822 }
28823 {
28824 arg4 = (int)(SWIG_As_int(obj3));
28825 if (SWIG_arg_fail(4)) SWIG_fail;
28826 }
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28830
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 {
28835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28836 }
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj;
28845 wxWindow *arg1 = (wxWindow *) 0 ;
28846 int arg2 ;
28847 bool result;
28848 PyObject * obj0 = 0 ;
28849 PyObject * obj1 = 0 ;
28850 char *kwnames[] = {
28851 (char *) "self",(char *) "hotkeyId", NULL
28852 };
28853
28854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28856 if (SWIG_arg_fail(1)) SWIG_fail;
28857 {
28858 arg2 = (int)(SWIG_As_int(obj1));
28859 if (SWIG_arg_fail(2)) SWIG_fail;
28860 }
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28864
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 {
28869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28870 }
28871 return resultobj;
28872 fail:
28873 return NULL;
28874 }
28875
28876
28877 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28878 PyObject *resultobj;
28879 wxWindow *arg1 = (wxWindow *) 0 ;
28880 wxPoint *arg2 = 0 ;
28881 wxPoint result;
28882 wxPoint temp2 ;
28883 PyObject * obj0 = 0 ;
28884 PyObject * obj1 = 0 ;
28885 char *kwnames[] = {
28886 (char *) "self",(char *) "pt", NULL
28887 };
28888
28889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28891 if (SWIG_arg_fail(1)) SWIG_fail;
28892 {
28893 arg2 = &temp2;
28894 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28895 }
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28899
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 {
28904 wxPoint * resultptr;
28905 resultptr = new wxPoint((wxPoint &)(result));
28906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28907 }
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28915 PyObject *resultobj;
28916 wxWindow *arg1 = (wxWindow *) 0 ;
28917 wxSize *arg2 = 0 ;
28918 wxSize result;
28919 wxSize temp2 ;
28920 PyObject * obj0 = 0 ;
28921 PyObject * obj1 = 0 ;
28922 char *kwnames[] = {
28923 (char *) "self",(char *) "sz", NULL
28924 };
28925
28926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28928 if (SWIG_arg_fail(1)) SWIG_fail;
28929 {
28930 arg2 = &temp2;
28931 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28932 }
28933 {
28934 PyThreadState* __tstate = wxPyBeginAllowThreads();
28935 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28936
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 {
28941 wxSize * resultptr;
28942 resultptr = new wxSize((wxSize &)(result));
28943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28944 }
28945 return resultobj;
28946 fail:
28947 return NULL;
28948 }
28949
28950
28951 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj;
28953 wxWindow *arg1 = (wxWindow *) 0 ;
28954 wxPoint *arg2 = 0 ;
28955 wxPoint result;
28956 wxPoint temp2 ;
28957 PyObject * obj0 = 0 ;
28958 PyObject * obj1 = 0 ;
28959 char *kwnames[] = {
28960 (char *) "self",(char *) "pt", NULL
28961 };
28962
28963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28965 if (SWIG_arg_fail(1)) SWIG_fail;
28966 {
28967 arg2 = &temp2;
28968 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28969 }
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 wxPoint * resultptr;
28979 resultptr = new wxPoint((wxPoint &)(result));
28980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28981 }
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj;
28990 wxWindow *arg1 = (wxWindow *) 0 ;
28991 wxSize *arg2 = 0 ;
28992 wxSize result;
28993 wxSize temp2 ;
28994 PyObject * obj0 = 0 ;
28995 PyObject * obj1 = 0 ;
28996 char *kwnames[] = {
28997 (char *) "self",(char *) "sz", NULL
28998 };
28999
29000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29002 if (SWIG_arg_fail(1)) SWIG_fail;
29003 {
29004 arg2 = &temp2;
29005 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29006 }
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 {
29015 wxSize * resultptr;
29016 resultptr = new wxSize((wxSize &)(result));
29017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29018 }
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29026 PyObject *resultobj;
29027 wxWindow *arg1 = (wxWindow *) 0 ;
29028 wxPoint *arg2 = 0 ;
29029 wxPoint result;
29030 wxPoint temp2 ;
29031 PyObject * obj0 = 0 ;
29032 PyObject * obj1 = 0 ;
29033 char *kwnames[] = {
29034 (char *) "self",(char *) "pt", NULL
29035 };
29036
29037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29039 if (SWIG_arg_fail(1)) SWIG_fail;
29040 {
29041 arg2 = &temp2;
29042 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29043 }
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 {
29052 wxPoint * resultptr;
29053 resultptr = new wxPoint((wxPoint &)(result));
29054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29055 }
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj;
29064 wxWindow *arg1 = (wxWindow *) 0 ;
29065 wxSize *arg2 = 0 ;
29066 wxSize result;
29067 wxSize temp2 ;
29068 PyObject * obj0 = 0 ;
29069 PyObject * obj1 = 0 ;
29070 char *kwnames[] = {
29071 (char *) "self",(char *) "sz", NULL
29072 };
29073
29074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29076 if (SWIG_arg_fail(1)) SWIG_fail;
29077 {
29078 arg2 = &temp2;
29079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29080 }
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29084
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 {
29089 wxSize * resultptr;
29090 resultptr = new wxSize((wxSize &)(result));
29091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29092 }
29093 return resultobj;
29094 fail:
29095 return NULL;
29096 }
29097
29098
29099 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29100 PyObject *resultobj;
29101 wxWindow *arg1 = (wxWindow *) 0 ;
29102 int arg2 ;
29103 int arg3 ;
29104 PyObject * obj0 = 0 ;
29105 PyObject * obj1 = 0 ;
29106 PyObject * obj2 = 0 ;
29107 char *kwnames[] = {
29108 (char *) "self",(char *) "x",(char *) "y", NULL
29109 };
29110
29111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29113 if (SWIG_arg_fail(1)) SWIG_fail;
29114 {
29115 arg2 = (int)(SWIG_As_int(obj1));
29116 if (SWIG_arg_fail(2)) SWIG_fail;
29117 }
29118 {
29119 arg3 = (int)(SWIG_As_int(obj2));
29120 if (SWIG_arg_fail(3)) SWIG_fail;
29121 }
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 (arg1)->WarpPointer(arg2,arg3);
29125
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 Py_INCREF(Py_None); resultobj = Py_None;
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29137 PyObject *resultobj;
29138 wxWindow *arg1 = (wxWindow *) 0 ;
29139 PyObject * obj0 = 0 ;
29140 char *kwnames[] = {
29141 (char *) "self", NULL
29142 };
29143
29144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29146 if (SWIG_arg_fail(1)) SWIG_fail;
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 (arg1)->CaptureMouse();
29150
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 Py_INCREF(Py_None); resultobj = Py_None;
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29162 PyObject *resultobj;
29163 wxWindow *arg1 = (wxWindow *) 0 ;
29164 PyObject * obj0 = 0 ;
29165 char *kwnames[] = {
29166 (char *) "self", NULL
29167 };
29168
29169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29171 if (SWIG_arg_fail(1)) SWIG_fail;
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 (arg1)->ReleaseMouse();
29175
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 Py_INCREF(Py_None); resultobj = Py_None;
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29187 PyObject *resultobj;
29188 wxWindow *result;
29189 char *kwnames[] = {
29190 NULL
29191 };
29192
29193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29194 {
29195 if (!wxPyCheckForApp()) SWIG_fail;
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 result = (wxWindow *)wxWindow::GetCapture();
29198
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 {
29203 resultobj = wxPyMake_wxObject(result, 0);
29204 }
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj;
29213 wxWindow *arg1 = (wxWindow *) 0 ;
29214 bool result;
29215 PyObject * obj0 = 0 ;
29216 char *kwnames[] = {
29217 (char *) "self", NULL
29218 };
29219
29220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29222 if (SWIG_arg_fail(1)) SWIG_fail;
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 result = (bool)((wxWindow const *)arg1)->HasCapture();
29226
29227 wxPyEndAllowThreads(__tstate);
29228 if (PyErr_Occurred()) SWIG_fail;
29229 }
29230 {
29231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29232 }
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29240 PyObject *resultobj;
29241 wxWindow *arg1 = (wxWindow *) 0 ;
29242 bool arg2 = (bool) true ;
29243 wxRect *arg3 = (wxRect *) NULL ;
29244 PyObject * obj0 = 0 ;
29245 PyObject * obj1 = 0 ;
29246 PyObject * obj2 = 0 ;
29247 char *kwnames[] = {
29248 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29249 };
29250
29251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29253 if (SWIG_arg_fail(1)) SWIG_fail;
29254 if (obj1) {
29255 {
29256 arg2 = (bool)(SWIG_As_bool(obj1));
29257 if (SWIG_arg_fail(2)) SWIG_fail;
29258 }
29259 }
29260 if (obj2) {
29261 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(3)) SWIG_fail;
29263 }
29264 {
29265 PyThreadState* __tstate = wxPyBeginAllowThreads();
29266 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29267
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 Py_INCREF(Py_None); resultobj = Py_None;
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj;
29280 wxWindow *arg1 = (wxWindow *) 0 ;
29281 wxRect *arg2 = 0 ;
29282 bool arg3 = (bool) true ;
29283 wxRect temp2 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 PyObject * obj2 = 0 ;
29287 char *kwnames[] = {
29288 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29289 };
29290
29291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29293 if (SWIG_arg_fail(1)) SWIG_fail;
29294 {
29295 arg2 = &temp2;
29296 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29297 }
29298 if (obj2) {
29299 {
29300 arg3 = (bool)(SWIG_As_bool(obj2));
29301 if (SWIG_arg_fail(3)) SWIG_fail;
29302 }
29303 }
29304 {
29305 PyThreadState* __tstate = wxPyBeginAllowThreads();
29306 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29307
29308 wxPyEndAllowThreads(__tstate);
29309 if (PyErr_Occurred()) SWIG_fail;
29310 }
29311 Py_INCREF(Py_None); resultobj = Py_None;
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29319 PyObject *resultobj;
29320 wxWindow *arg1 = (wxWindow *) 0 ;
29321 PyObject * obj0 = 0 ;
29322 char *kwnames[] = {
29323 (char *) "self", NULL
29324 };
29325
29326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29328 if (SWIG_arg_fail(1)) SWIG_fail;
29329 {
29330 PyThreadState* __tstate = wxPyBeginAllowThreads();
29331 (arg1)->Update();
29332
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 Py_INCREF(Py_None); resultobj = Py_None;
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj;
29345 wxWindow *arg1 = (wxWindow *) 0 ;
29346 PyObject * obj0 = 0 ;
29347 char *kwnames[] = {
29348 (char *) "self", NULL
29349 };
29350
29351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29353 if (SWIG_arg_fail(1)) SWIG_fail;
29354 {
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 (arg1)->ClearBackground();
29357
29358 wxPyEndAllowThreads(__tstate);
29359 if (PyErr_Occurred()) SWIG_fail;
29360 }
29361 Py_INCREF(Py_None); resultobj = Py_None;
29362 return resultobj;
29363 fail:
29364 return NULL;
29365 }
29366
29367
29368 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29369 PyObject *resultobj;
29370 wxWindow *arg1 = (wxWindow *) 0 ;
29371 PyObject * obj0 = 0 ;
29372 char *kwnames[] = {
29373 (char *) "self", NULL
29374 };
29375
29376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29378 if (SWIG_arg_fail(1)) SWIG_fail;
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 (arg1)->Freeze();
29382
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 Py_INCREF(Py_None); resultobj = Py_None;
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj;
29395 wxWindow *arg1 = (wxWindow *) 0 ;
29396 PyObject * obj0 = 0 ;
29397 char *kwnames[] = {
29398 (char *) "self", NULL
29399 };
29400
29401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 (arg1)->Thaw();
29407
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 Py_INCREF(Py_None); resultobj = Py_None;
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj;
29420 wxWindow *arg1 = (wxWindow *) 0 ;
29421 wxDC *arg2 = 0 ;
29422 PyObject * obj0 = 0 ;
29423 PyObject * obj1 = 0 ;
29424 char *kwnames[] = {
29425 (char *) "self",(char *) "dc", NULL
29426 };
29427
29428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29430 if (SWIG_arg_fail(1)) SWIG_fail;
29431 {
29432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29433 if (SWIG_arg_fail(2)) SWIG_fail;
29434 if (arg2 == NULL) {
29435 SWIG_null_ref("wxDC");
29436 }
29437 if (SWIG_arg_fail(2)) SWIG_fail;
29438 }
29439 {
29440 PyThreadState* __tstate = wxPyBeginAllowThreads();
29441 (arg1)->PrepareDC(*arg2);
29442
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 Py_INCREF(Py_None); resultobj = Py_None;
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29454 PyObject *resultobj;
29455 wxWindow *arg1 = (wxWindow *) 0 ;
29456 wxRegion *result;
29457 PyObject * obj0 = 0 ;
29458 char *kwnames[] = {
29459 (char *) "self", NULL
29460 };
29461
29462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29464 if (SWIG_arg_fail(1)) SWIG_fail;
29465 {
29466 PyThreadState* __tstate = wxPyBeginAllowThreads();
29467 {
29468 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29469 result = (wxRegion *) &_result_ref;
29470 }
29471
29472 wxPyEndAllowThreads(__tstate);
29473 if (PyErr_Occurred()) SWIG_fail;
29474 }
29475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29476 return resultobj;
29477 fail:
29478 return NULL;
29479 }
29480
29481
29482 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29483 PyObject *resultobj;
29484 wxWindow *arg1 = (wxWindow *) 0 ;
29485 wxRect result;
29486 PyObject * obj0 = 0 ;
29487 char *kwnames[] = {
29488 (char *) "self", NULL
29489 };
29490
29491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29493 if (SWIG_arg_fail(1)) SWIG_fail;
29494 {
29495 PyThreadState* __tstate = wxPyBeginAllowThreads();
29496 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29497
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 {
29502 wxRect * resultptr;
29503 resultptr = new wxRect((wxRect &)(result));
29504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29505 }
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29513 PyObject *resultobj;
29514 wxWindow *arg1 = (wxWindow *) 0 ;
29515 int arg2 ;
29516 int arg3 ;
29517 int arg4 = (int) 1 ;
29518 int arg5 = (int) 1 ;
29519 bool result;
29520 PyObject * obj0 = 0 ;
29521 PyObject * obj1 = 0 ;
29522 PyObject * obj2 = 0 ;
29523 PyObject * obj3 = 0 ;
29524 PyObject * obj4 = 0 ;
29525 char *kwnames[] = {
29526 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29527 };
29528
29529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29531 if (SWIG_arg_fail(1)) SWIG_fail;
29532 {
29533 arg2 = (int)(SWIG_As_int(obj1));
29534 if (SWIG_arg_fail(2)) SWIG_fail;
29535 }
29536 {
29537 arg3 = (int)(SWIG_As_int(obj2));
29538 if (SWIG_arg_fail(3)) SWIG_fail;
29539 }
29540 if (obj3) {
29541 {
29542 arg4 = (int)(SWIG_As_int(obj3));
29543 if (SWIG_arg_fail(4)) SWIG_fail;
29544 }
29545 }
29546 if (obj4) {
29547 {
29548 arg5 = (int)(SWIG_As_int(obj4));
29549 if (SWIG_arg_fail(5)) SWIG_fail;
29550 }
29551 }
29552 {
29553 PyThreadState* __tstate = wxPyBeginAllowThreads();
29554 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29555
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29561 }
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj;
29570 wxWindow *arg1 = (wxWindow *) 0 ;
29571 wxPoint *arg2 = 0 ;
29572 bool result;
29573 wxPoint temp2 ;
29574 PyObject * obj0 = 0 ;
29575 PyObject * obj1 = 0 ;
29576 char *kwnames[] = {
29577 (char *) "self",(char *) "pt", NULL
29578 };
29579
29580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29582 if (SWIG_arg_fail(1)) SWIG_fail;
29583 {
29584 arg2 = &temp2;
29585 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29586 }
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29590
29591 wxPyEndAllowThreads(__tstate);
29592 if (PyErr_Occurred()) SWIG_fail;
29593 }
29594 {
29595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29596 }
29597 return resultobj;
29598 fail:
29599 return NULL;
29600 }
29601
29602
29603 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29604 PyObject *resultobj;
29605 wxWindow *arg1 = (wxWindow *) 0 ;
29606 wxRect *arg2 = 0 ;
29607 bool result;
29608 wxRect temp2 ;
29609 PyObject * obj0 = 0 ;
29610 PyObject * obj1 = 0 ;
29611 char *kwnames[] = {
29612 (char *) "self",(char *) "rect", NULL
29613 };
29614
29615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29617 if (SWIG_arg_fail(1)) SWIG_fail;
29618 {
29619 arg2 = &temp2;
29620 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29621 }
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29625
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 {
29630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29631 }
29632 return resultobj;
29633 fail:
29634 return NULL;
29635 }
29636
29637
29638 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29639 PyObject *resultobj;
29640 wxWindow *arg1 = (wxWindow *) 0 ;
29641 wxVisualAttributes result;
29642 PyObject * obj0 = 0 ;
29643 char *kwnames[] = {
29644 (char *) "self", NULL
29645 };
29646
29647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29649 if (SWIG_arg_fail(1)) SWIG_fail;
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29653
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 {
29658 wxVisualAttributes * resultptr;
29659 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29661 }
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29669 PyObject *resultobj;
29670 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29671 wxVisualAttributes result;
29672 PyObject * obj0 = 0 ;
29673 char *kwnames[] = {
29674 (char *) "variant", NULL
29675 };
29676
29677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29678 if (obj0) {
29679 {
29680 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29681 if (SWIG_arg_fail(1)) SWIG_fail;
29682 }
29683 }
29684 {
29685 if (!wxPyCheckForApp()) SWIG_fail;
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29688
29689 wxPyEndAllowThreads(__tstate);
29690 if (PyErr_Occurred()) SWIG_fail;
29691 }
29692 {
29693 wxVisualAttributes * resultptr;
29694 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29695 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29696 }
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj;
29705 wxWindow *arg1 = (wxWindow *) 0 ;
29706 wxColour *arg2 = 0 ;
29707 bool result;
29708 wxColour temp2 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 char *kwnames[] = {
29712 (char *) "self",(char *) "colour", NULL
29713 };
29714
29715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29717 if (SWIG_arg_fail(1)) SWIG_fail;
29718 {
29719 arg2 = &temp2;
29720 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29721 }
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29725
29726 wxPyEndAllowThreads(__tstate);
29727 if (PyErr_Occurred()) SWIG_fail;
29728 }
29729 {
29730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29731 }
29732 return resultobj;
29733 fail:
29734 return NULL;
29735 }
29736
29737
29738 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29739 PyObject *resultobj;
29740 wxWindow *arg1 = (wxWindow *) 0 ;
29741 wxColour *arg2 = 0 ;
29742 wxColour temp2 ;
29743 PyObject * obj0 = 0 ;
29744 PyObject * obj1 = 0 ;
29745 char *kwnames[] = {
29746 (char *) "self",(char *) "colour", NULL
29747 };
29748
29749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29751 if (SWIG_arg_fail(1)) SWIG_fail;
29752 {
29753 arg2 = &temp2;
29754 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29755 }
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29759
29760 wxPyEndAllowThreads(__tstate);
29761 if (PyErr_Occurred()) SWIG_fail;
29762 }
29763 Py_INCREF(Py_None); resultobj = Py_None;
29764 return resultobj;
29765 fail:
29766 return NULL;
29767 }
29768
29769
29770 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29771 PyObject *resultobj;
29772 wxWindow *arg1 = (wxWindow *) 0 ;
29773 wxColour *arg2 = 0 ;
29774 bool result;
29775 wxColour temp2 ;
29776 PyObject * obj0 = 0 ;
29777 PyObject * obj1 = 0 ;
29778 char *kwnames[] = {
29779 (char *) "self",(char *) "colour", NULL
29780 };
29781
29782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29784 if (SWIG_arg_fail(1)) SWIG_fail;
29785 {
29786 arg2 = &temp2;
29787 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29788 }
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29792
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 {
29797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29798 }
29799 return resultobj;
29800 fail:
29801 return NULL;
29802 }
29803
29804
29805 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29806 PyObject *resultobj;
29807 wxWindow *arg1 = (wxWindow *) 0 ;
29808 wxColour *arg2 = 0 ;
29809 wxColour temp2 ;
29810 PyObject * obj0 = 0 ;
29811 PyObject * obj1 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self",(char *) "colour", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 {
29820 arg2 = &temp2;
29821 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29822 }
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 Py_INCREF(Py_None); resultobj = Py_None;
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxWindow *arg1 = (wxWindow *) 0 ;
29840 wxColour result;
29841 PyObject * obj0 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 {
29857 wxColour * resultptr;
29858 resultptr = new wxColour((wxColour &)(result));
29859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29860 }
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj;
29869 wxWindow *arg1 = (wxWindow *) 0 ;
29870 wxColour result;
29871 PyObject * obj0 = 0 ;
29872 char *kwnames[] = {
29873 (char *) "self", NULL
29874 };
29875
29876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29878 if (SWIG_arg_fail(1)) SWIG_fail;
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = ((wxWindow const *)arg1)->GetForegroundColour();
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 {
29887 wxColour * resultptr;
29888 resultptr = new wxColour((wxColour &)(result));
29889 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29890 }
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29898 PyObject *resultobj;
29899 wxWindow *arg1 = (wxWindow *) 0 ;
29900 bool result;
29901 PyObject * obj0 = 0 ;
29902 char *kwnames[] = {
29903 (char *) "self", NULL
29904 };
29905
29906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29908 if (SWIG_arg_fail(1)) SWIG_fail;
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29912
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 {
29917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29918 }
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj;
29927 wxWindow *arg1 = (wxWindow *) 0 ;
29928 bool result;
29929 PyObject * obj0 = 0 ;
29930 char *kwnames[] = {
29931 (char *) "self", NULL
29932 };
29933
29934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29936 if (SWIG_arg_fail(1)) SWIG_fail;
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 {
29945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29946 }
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj;
29955 wxWindow *arg1 = (wxWindow *) 0 ;
29956 wxBackgroundStyle arg2 ;
29957 bool result;
29958 PyObject * obj0 = 0 ;
29959 PyObject * obj1 = 0 ;
29960 char *kwnames[] = {
29961 (char *) "self",(char *) "style", NULL
29962 };
29963
29964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29966 if (SWIG_arg_fail(1)) SWIG_fail;
29967 {
29968 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29969 if (SWIG_arg_fail(2)) SWIG_fail;
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxWindow *arg1 = (wxWindow *) 0 ;
29990 wxBackgroundStyle result;
29991 PyObject * obj0 = 0 ;
29992 char *kwnames[] = {
29993 (char *) "self", NULL
29994 };
29995
29996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29998 if (SWIG_arg_fail(1)) SWIG_fail;
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30002
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 resultobj = SWIG_From_int((result));
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 bool result;
30017 PyObject * obj0 = 0 ;
30018 char *kwnames[] = {
30019 (char *) "self", NULL
30020 };
30021
30022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30024 if (SWIG_arg_fail(1)) SWIG_fail;
30025 {
30026 PyThreadState* __tstate = wxPyBeginAllowThreads();
30027 result = (bool)(arg1)->HasTransparentBackground();
30028
30029 wxPyEndAllowThreads(__tstate);
30030 if (PyErr_Occurred()) SWIG_fail;
30031 }
30032 {
30033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30034 }
30035 return resultobj;
30036 fail:
30037 return NULL;
30038 }
30039
30040
30041 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30042 PyObject *resultobj;
30043 wxWindow *arg1 = (wxWindow *) 0 ;
30044 wxCursor *arg2 = 0 ;
30045 bool result;
30046 PyObject * obj0 = 0 ;
30047 PyObject * obj1 = 0 ;
30048 char *kwnames[] = {
30049 (char *) "self",(char *) "cursor", NULL
30050 };
30051
30052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30054 if (SWIG_arg_fail(1)) SWIG_fail;
30055 {
30056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(2)) SWIG_fail;
30058 if (arg2 == NULL) {
30059 SWIG_null_ref("wxCursor");
30060 }
30061 if (SWIG_arg_fail(2)) SWIG_fail;
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30066
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 {
30071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30072 }
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30080 PyObject *resultobj;
30081 wxWindow *arg1 = (wxWindow *) 0 ;
30082 wxCursor result;
30083 PyObject * obj0 = 0 ;
30084 char *kwnames[] = {
30085 (char *) "self", NULL
30086 };
30087
30088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30090 if (SWIG_arg_fail(1)) SWIG_fail;
30091 {
30092 PyThreadState* __tstate = wxPyBeginAllowThreads();
30093 result = (arg1)->GetCursor();
30094
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 {
30099 wxCursor * resultptr;
30100 resultptr = new wxCursor((wxCursor &)(result));
30101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30102 }
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30110 PyObject *resultobj;
30111 wxWindow *arg1 = (wxWindow *) 0 ;
30112 wxFont *arg2 = 0 ;
30113 bool result;
30114 PyObject * obj0 = 0 ;
30115 PyObject * obj1 = 0 ;
30116 char *kwnames[] = {
30117 (char *) "self",(char *) "font", NULL
30118 };
30119
30120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30122 if (SWIG_arg_fail(1)) SWIG_fail;
30123 {
30124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30125 if (SWIG_arg_fail(2)) SWIG_fail;
30126 if (arg2 == NULL) {
30127 SWIG_null_ref("wxFont");
30128 }
30129 if (SWIG_arg_fail(2)) SWIG_fail;
30130 }
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30134
30135 wxPyEndAllowThreads(__tstate);
30136 if (PyErr_Occurred()) SWIG_fail;
30137 }
30138 {
30139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30140 }
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30148 PyObject *resultobj;
30149 wxWindow *arg1 = (wxWindow *) 0 ;
30150 wxFont *arg2 = 0 ;
30151 PyObject * obj0 = 0 ;
30152 PyObject * obj1 = 0 ;
30153 char *kwnames[] = {
30154 (char *) "self",(char *) "font", NULL
30155 };
30156
30157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30159 if (SWIG_arg_fail(1)) SWIG_fail;
30160 {
30161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30162 if (SWIG_arg_fail(2)) SWIG_fail;
30163 if (arg2 == NULL) {
30164 SWIG_null_ref("wxFont");
30165 }
30166 if (SWIG_arg_fail(2)) SWIG_fail;
30167 }
30168 {
30169 PyThreadState* __tstate = wxPyBeginAllowThreads();
30170 (arg1)->SetOwnFont((wxFont const &)*arg2);
30171
30172 wxPyEndAllowThreads(__tstate);
30173 if (PyErr_Occurred()) SWIG_fail;
30174 }
30175 Py_INCREF(Py_None); resultobj = Py_None;
30176 return resultobj;
30177 fail:
30178 return NULL;
30179 }
30180
30181
30182 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30183 PyObject *resultobj;
30184 wxWindow *arg1 = (wxWindow *) 0 ;
30185 wxFont result;
30186 PyObject * obj0 = 0 ;
30187 char *kwnames[] = {
30188 (char *) "self", NULL
30189 };
30190
30191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30193 if (SWIG_arg_fail(1)) SWIG_fail;
30194 {
30195 PyThreadState* __tstate = wxPyBeginAllowThreads();
30196 result = (arg1)->GetFont();
30197
30198 wxPyEndAllowThreads(__tstate);
30199 if (PyErr_Occurred()) SWIG_fail;
30200 }
30201 {
30202 wxFont * resultptr;
30203 resultptr = new wxFont((wxFont &)(result));
30204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30205 }
30206 return resultobj;
30207 fail:
30208 return NULL;
30209 }
30210
30211
30212 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30213 PyObject *resultobj;
30214 wxWindow *arg1 = (wxWindow *) 0 ;
30215 wxCaret *arg2 = (wxCaret *) 0 ;
30216 PyObject * obj0 = 0 ;
30217 PyObject * obj1 = 0 ;
30218 char *kwnames[] = {
30219 (char *) "self",(char *) "caret", NULL
30220 };
30221
30222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30224 if (SWIG_arg_fail(1)) SWIG_fail;
30225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30226 if (SWIG_arg_fail(2)) SWIG_fail;
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 (arg1)->SetCaret(arg2);
30230
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 Py_INCREF(Py_None); resultobj = Py_None;
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj;
30243 wxWindow *arg1 = (wxWindow *) 0 ;
30244 wxCaret *result;
30245 PyObject * obj0 = 0 ;
30246 char *kwnames[] = {
30247 (char *) "self", NULL
30248 };
30249
30250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30252 if (SWIG_arg_fail(1)) SWIG_fail;
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30256
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30261 return resultobj;
30262 fail:
30263 return NULL;
30264 }
30265
30266
30267 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj;
30269 wxWindow *arg1 = (wxWindow *) 0 ;
30270 int result;
30271 PyObject * obj0 = 0 ;
30272 char *kwnames[] = {
30273 (char *) "self", NULL
30274 };
30275
30276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30278 if (SWIG_arg_fail(1)) SWIG_fail;
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30282
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 {
30287 resultobj = SWIG_From_int((int)(result));
30288 }
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30296 PyObject *resultobj;
30297 wxWindow *arg1 = (wxWindow *) 0 ;
30298 int result;
30299 PyObject * obj0 = 0 ;
30300 char *kwnames[] = {
30301 (char *) "self", NULL
30302 };
30303
30304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30306 if (SWIG_arg_fail(1)) SWIG_fail;
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30310
30311 wxPyEndAllowThreads(__tstate);
30312 if (PyErr_Occurred()) SWIG_fail;
30313 }
30314 {
30315 resultobj = SWIG_From_int((int)(result));
30316 }
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj;
30325 wxWindow *arg1 = (wxWindow *) 0 ;
30326 wxString *arg2 = 0 ;
30327 int *arg3 = (int *) 0 ;
30328 int *arg4 = (int *) 0 ;
30329 bool temp2 = false ;
30330 int temp3 ;
30331 int res3 = 0 ;
30332 int temp4 ;
30333 int res4 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char *kwnames[] = {
30337 (char *) "self",(char *) "string", NULL
30338 };
30339
30340 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30341 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30344 if (SWIG_arg_fail(1)) SWIG_fail;
30345 {
30346 arg2 = wxString_in_helper(obj1);
30347 if (arg2 == NULL) SWIG_fail;
30348 temp2 = true;
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 Py_INCREF(Py_None); resultobj = Py_None;
30358 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30359 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30360 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30361 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30362 {
30363 if (temp2)
30364 delete arg2;
30365 }
30366 return resultobj;
30367 fail:
30368 {
30369 if (temp2)
30370 delete arg2;
30371 }
30372 return NULL;
30373 }
30374
30375
30376 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30377 PyObject *resultobj;
30378 wxWindow *arg1 = (wxWindow *) 0 ;
30379 wxString *arg2 = 0 ;
30380 int *arg3 = (int *) 0 ;
30381 int *arg4 = (int *) 0 ;
30382 int *arg5 = (int *) 0 ;
30383 int *arg6 = (int *) 0 ;
30384 wxFont *arg7 = (wxFont *) NULL ;
30385 bool temp2 = false ;
30386 int temp3 ;
30387 int res3 = 0 ;
30388 int temp4 ;
30389 int res4 = 0 ;
30390 int temp5 ;
30391 int res5 = 0 ;
30392 int temp6 ;
30393 int res6 = 0 ;
30394 PyObject * obj0 = 0 ;
30395 PyObject * obj1 = 0 ;
30396 PyObject * obj2 = 0 ;
30397 char *kwnames[] = {
30398 (char *) "self",(char *) "string",(char *) "font", NULL
30399 };
30400
30401 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30402 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30403 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30404 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30407 if (SWIG_arg_fail(1)) SWIG_fail;
30408 {
30409 arg2 = wxString_in_helper(obj1);
30410 if (arg2 == NULL) SWIG_fail;
30411 temp2 = true;
30412 }
30413 if (obj2) {
30414 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(7)) SWIG_fail;
30416 }
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30420
30421 wxPyEndAllowThreads(__tstate);
30422 if (PyErr_Occurred()) SWIG_fail;
30423 }
30424 Py_INCREF(Py_None); resultobj = Py_None;
30425 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30426 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30427 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30428 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30429 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30430 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30431 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30432 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30433 {
30434 if (temp2)
30435 delete arg2;
30436 }
30437 return resultobj;
30438 fail:
30439 {
30440 if (temp2)
30441 delete arg2;
30442 }
30443 return NULL;
30444 }
30445
30446
30447 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30448 PyObject *resultobj;
30449 wxWindow *arg1 = (wxWindow *) 0 ;
30450 int *arg2 = (int *) 0 ;
30451 int *arg3 = (int *) 0 ;
30452 int temp2 ;
30453 int res2 = 0 ;
30454 int temp3 ;
30455 int res3 = 0 ;
30456 PyObject * obj0 = 0 ;
30457 PyObject * obj1 = 0 ;
30458 PyObject * obj2 = 0 ;
30459 char *kwnames[] = {
30460 (char *) "self",(char *) "x",(char *) "y", NULL
30461 };
30462
30463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30465 if (SWIG_arg_fail(1)) SWIG_fail;
30466 {
30467 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30468 temp2 = SWIG_As_int(obj1);
30469 if (SWIG_arg_fail(2)) SWIG_fail;
30470 arg2 = &temp2;
30471 res2 = SWIG_NEWOBJ;
30472 }
30473 }
30474 {
30475 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30476 temp3 = SWIG_As_int(obj2);
30477 if (SWIG_arg_fail(3)) SWIG_fail;
30478 arg3 = &temp3;
30479 res3 = SWIG_NEWOBJ;
30480 }
30481 }
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30485
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 Py_INCREF(Py_None); resultobj = Py_None;
30490 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30491 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30492 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30493 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj;
30502 wxWindow *arg1 = (wxWindow *) 0 ;
30503 int *arg2 = (int *) 0 ;
30504 int *arg3 = (int *) 0 ;
30505 int temp2 ;
30506 int res2 = 0 ;
30507 int temp3 ;
30508 int res3 = 0 ;
30509 PyObject * obj0 = 0 ;
30510 PyObject * obj1 = 0 ;
30511 PyObject * obj2 = 0 ;
30512 char *kwnames[] = {
30513 (char *) "self",(char *) "x",(char *) "y", NULL
30514 };
30515
30516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30518 if (SWIG_arg_fail(1)) SWIG_fail;
30519 {
30520 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30521 temp2 = SWIG_As_int(obj1);
30522 if (SWIG_arg_fail(2)) SWIG_fail;
30523 arg2 = &temp2;
30524 res2 = SWIG_NEWOBJ;
30525 }
30526 }
30527 {
30528 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30529 temp3 = SWIG_As_int(obj2);
30530 if (SWIG_arg_fail(3)) SWIG_fail;
30531 arg3 = &temp3;
30532 res3 = SWIG_NEWOBJ;
30533 }
30534 }
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30538
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 Py_INCREF(Py_None); resultobj = Py_None;
30543 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30544 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30545 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30546 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30554 PyObject *resultobj;
30555 wxWindow *arg1 = (wxWindow *) 0 ;
30556 wxPoint *arg2 = 0 ;
30557 wxPoint result;
30558 wxPoint temp2 ;
30559 PyObject * obj0 = 0 ;
30560 PyObject * obj1 = 0 ;
30561 char *kwnames[] = {
30562 (char *) "self",(char *) "pt", NULL
30563 };
30564
30565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30567 if (SWIG_arg_fail(1)) SWIG_fail;
30568 {
30569 arg2 = &temp2;
30570 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30571 }
30572 {
30573 PyThreadState* __tstate = wxPyBeginAllowThreads();
30574 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30575
30576 wxPyEndAllowThreads(__tstate);
30577 if (PyErr_Occurred()) SWIG_fail;
30578 }
30579 {
30580 wxPoint * resultptr;
30581 resultptr = new wxPoint((wxPoint &)(result));
30582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30583 }
30584 return resultobj;
30585 fail:
30586 return NULL;
30587 }
30588
30589
30590 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30591 PyObject *resultobj;
30592 wxWindow *arg1 = (wxWindow *) 0 ;
30593 wxPoint *arg2 = 0 ;
30594 wxPoint result;
30595 wxPoint temp2 ;
30596 PyObject * obj0 = 0 ;
30597 PyObject * obj1 = 0 ;
30598 char *kwnames[] = {
30599 (char *) "self",(char *) "pt", NULL
30600 };
30601
30602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30604 if (SWIG_arg_fail(1)) SWIG_fail;
30605 {
30606 arg2 = &temp2;
30607 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30608 }
30609 {
30610 PyThreadState* __tstate = wxPyBeginAllowThreads();
30611 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30612
30613 wxPyEndAllowThreads(__tstate);
30614 if (PyErr_Occurred()) SWIG_fail;
30615 }
30616 {
30617 wxPoint * resultptr;
30618 resultptr = new wxPoint((wxPoint &)(result));
30619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30620 }
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 wxWindow *arg1 = (wxWindow *) 0 ;
30630 int arg2 ;
30631 int arg3 ;
30632 wxHitTest result;
30633 PyObject * obj0 = 0 ;
30634 PyObject * obj1 = 0 ;
30635 PyObject * obj2 = 0 ;
30636 char *kwnames[] = {
30637 (char *) "self",(char *) "x",(char *) "y", NULL
30638 };
30639
30640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30642 if (SWIG_arg_fail(1)) SWIG_fail;
30643 {
30644 arg2 = (int)(SWIG_As_int(obj1));
30645 if (SWIG_arg_fail(2)) SWIG_fail;
30646 }
30647 {
30648 arg3 = (int)(SWIG_As_int(obj2));
30649 if (SWIG_arg_fail(3)) SWIG_fail;
30650 }
30651 {
30652 PyThreadState* __tstate = wxPyBeginAllowThreads();
30653 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30654
30655 wxPyEndAllowThreads(__tstate);
30656 if (PyErr_Occurred()) SWIG_fail;
30657 }
30658 resultobj = SWIG_From_int((result));
30659 return resultobj;
30660 fail:
30661 return NULL;
30662 }
30663
30664
30665 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30666 PyObject *resultobj;
30667 wxWindow *arg1 = (wxWindow *) 0 ;
30668 wxPoint *arg2 = 0 ;
30669 wxHitTest result;
30670 wxPoint temp2 ;
30671 PyObject * obj0 = 0 ;
30672 PyObject * obj1 = 0 ;
30673 char *kwnames[] = {
30674 (char *) "self",(char *) "pt", NULL
30675 };
30676
30677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30679 if (SWIG_arg_fail(1)) SWIG_fail;
30680 {
30681 arg2 = &temp2;
30682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30683 }
30684 {
30685 PyThreadState* __tstate = wxPyBeginAllowThreads();
30686 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30687
30688 wxPyEndAllowThreads(__tstate);
30689 if (PyErr_Occurred()) SWIG_fail;
30690 }
30691 resultobj = SWIG_From_int((result));
30692 return resultobj;
30693 fail:
30694 return NULL;
30695 }
30696
30697
30698 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30699 PyObject *resultobj;
30700 wxWindow *arg1 = (wxWindow *) 0 ;
30701 long arg2 ;
30702 wxBorder result;
30703 PyObject * obj0 = 0 ;
30704 PyObject * obj1 = 0 ;
30705
30706 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30708 if (SWIG_arg_fail(1)) SWIG_fail;
30709 {
30710 arg2 = (long)(SWIG_As_long(obj1));
30711 if (SWIG_arg_fail(2)) SWIG_fail;
30712 }
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
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__SWIG_1(PyObject *, PyObject *args) {
30728 PyObject *resultobj;
30729 wxWindow *arg1 = (wxWindow *) 0 ;
30730 wxBorder result;
30731 PyObject * obj0 = 0 ;
30732
30733 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30735 if (SWIG_arg_fail(1)) SWIG_fail;
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30739
30740 wxPyEndAllowThreads(__tstate);
30741 if (PyErr_Occurred()) SWIG_fail;
30742 }
30743 resultobj = SWIG_From_int((result));
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30751 int argc;
30752 PyObject *argv[3];
30753 int ii;
30754
30755 argc = PyObject_Length(args);
30756 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30757 argv[ii] = PyTuple_GetItem(args,ii);
30758 }
30759 if (argc == 1) {
30760 int _v;
30761 {
30762 void *ptr;
30763 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30764 _v = 0;
30765 PyErr_Clear();
30766 } else {
30767 _v = 1;
30768 }
30769 }
30770 if (_v) {
30771 return _wrap_Window_GetBorder__SWIG_1(self,args);
30772 }
30773 }
30774 if (argc == 2) {
30775 int _v;
30776 {
30777 void *ptr;
30778 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30779 _v = 0;
30780 PyErr_Clear();
30781 } else {
30782 _v = 1;
30783 }
30784 }
30785 if (_v) {
30786 _v = SWIG_Check_long(argv[1]);
30787 if (_v) {
30788 return _wrap_Window_GetBorder__SWIG_0(self,args);
30789 }
30790 }
30791 }
30792
30793 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30794 return NULL;
30795 }
30796
30797
30798 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30799 PyObject *resultobj;
30800 wxWindow *arg1 = (wxWindow *) 0 ;
30801 long arg2 = (long) wxUPDATE_UI_NONE ;
30802 PyObject * obj0 = 0 ;
30803 PyObject * obj1 = 0 ;
30804 char *kwnames[] = {
30805 (char *) "self",(char *) "flags", NULL
30806 };
30807
30808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30810 if (SWIG_arg_fail(1)) SWIG_fail;
30811 if (obj1) {
30812 {
30813 arg2 = (long)(SWIG_As_long(obj1));
30814 if (SWIG_arg_fail(2)) SWIG_fail;
30815 }
30816 }
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 (arg1)->UpdateWindowUI(arg2);
30820
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 Py_INCREF(Py_None); resultobj = Py_None;
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj;
30833 wxWindow *arg1 = (wxWindow *) 0 ;
30834 wxMenu *arg2 = (wxMenu *) 0 ;
30835 int arg3 = (int) -1 ;
30836 int arg4 = (int) -1 ;
30837 bool result;
30838 PyObject * obj0 = 0 ;
30839 PyObject * obj1 = 0 ;
30840 PyObject * obj2 = 0 ;
30841 PyObject * obj3 = 0 ;
30842 char *kwnames[] = {
30843 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30844 };
30845
30846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30848 if (SWIG_arg_fail(1)) SWIG_fail;
30849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(2)) SWIG_fail;
30851 if (obj2) {
30852 {
30853 arg3 = (int)(SWIG_As_int(obj2));
30854 if (SWIG_arg_fail(3)) SWIG_fail;
30855 }
30856 }
30857 if (obj3) {
30858 {
30859 arg4 = (int)(SWIG_As_int(obj3));
30860 if (SWIG_arg_fail(4)) SWIG_fail;
30861 }
30862 }
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30866
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 {
30871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30872 }
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30880 PyObject *resultobj;
30881 wxWindow *arg1 = (wxWindow *) 0 ;
30882 wxMenu *arg2 = (wxMenu *) 0 ;
30883 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30884 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30885 bool result;
30886 wxPoint temp3 ;
30887 PyObject * obj0 = 0 ;
30888 PyObject * obj1 = 0 ;
30889 PyObject * obj2 = 0 ;
30890 char *kwnames[] = {
30891 (char *) "self",(char *) "menu",(char *) "pos", NULL
30892 };
30893
30894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30896 if (SWIG_arg_fail(1)) SWIG_fail;
30897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30898 if (SWIG_arg_fail(2)) SWIG_fail;
30899 if (obj2) {
30900 {
30901 arg3 = &temp3;
30902 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30903 }
30904 }
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30908
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 {
30913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30914 }
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj;
30923 wxWindow *arg1 = (wxWindow *) 0 ;
30924 long result;
30925 PyObject * obj0 = 0 ;
30926 char *kwnames[] = {
30927 (char *) "self", NULL
30928 };
30929
30930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30932 if (SWIG_arg_fail(1)) SWIG_fail;
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = (long)wxWindow_GetHandle(arg1);
30936
30937 wxPyEndAllowThreads(__tstate);
30938 if (PyErr_Occurred()) SWIG_fail;
30939 }
30940 {
30941 resultobj = SWIG_From_long((long)(result));
30942 }
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj;
30951 wxWindow *arg1 = (wxWindow *) 0 ;
30952 long arg2 ;
30953 PyObject * obj0 = 0 ;
30954 PyObject * obj1 = 0 ;
30955 char *kwnames[] = {
30956 (char *) "self",(char *) "handle", NULL
30957 };
30958
30959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30961 if (SWIG_arg_fail(1)) SWIG_fail;
30962 {
30963 arg2 = (long)(SWIG_As_long(obj1));
30964 if (SWIG_arg_fail(2)) SWIG_fail;
30965 }
30966 {
30967 PyThreadState* __tstate = wxPyBeginAllowThreads();
30968 wxWindow_AssociateHandle(arg1,arg2);
30969
30970 wxPyEndAllowThreads(__tstate);
30971 if (PyErr_Occurred()) SWIG_fail;
30972 }
30973 Py_INCREF(Py_None); resultobj = Py_None;
30974 return resultobj;
30975 fail:
30976 return NULL;
30977 }
30978
30979
30980 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30981 PyObject *resultobj;
30982 wxWindow *arg1 = (wxWindow *) 0 ;
30983 PyObject * obj0 = 0 ;
30984 char *kwnames[] = {
30985 (char *) "self", NULL
30986 };
30987
30988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30990 if (SWIG_arg_fail(1)) SWIG_fail;
30991 {
30992 PyThreadState* __tstate = wxPyBeginAllowThreads();
30993 (arg1)->DissociateHandle();
30994
30995 wxPyEndAllowThreads(__tstate);
30996 if (PyErr_Occurred()) SWIG_fail;
30997 }
30998 Py_INCREF(Py_None); resultobj = Py_None;
30999 return resultobj;
31000 fail:
31001 return NULL;
31002 }
31003
31004
31005 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31006 PyObject *resultobj;
31007 wxWindow *arg1 = (wxWindow *) 0 ;
31008 int arg2 ;
31009 bool result;
31010 PyObject * obj0 = 0 ;
31011 PyObject * obj1 = 0 ;
31012 char *kwnames[] = {
31013 (char *) "self",(char *) "orient", NULL
31014 };
31015
31016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31018 if (SWIG_arg_fail(1)) SWIG_fail;
31019 {
31020 arg2 = (int)(SWIG_As_int(obj1));
31021 if (SWIG_arg_fail(2)) SWIG_fail;
31022 }
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31026
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 {
31031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31032 }
31033 return resultobj;
31034 fail:
31035 return NULL;
31036 }
31037
31038
31039 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31040 PyObject *resultobj;
31041 wxWindow *arg1 = (wxWindow *) 0 ;
31042 int arg2 ;
31043 int arg3 ;
31044 int arg4 ;
31045 int arg5 ;
31046 bool arg6 = (bool) true ;
31047 PyObject * obj0 = 0 ;
31048 PyObject * obj1 = 0 ;
31049 PyObject * obj2 = 0 ;
31050 PyObject * obj3 = 0 ;
31051 PyObject * obj4 = 0 ;
31052 PyObject * obj5 = 0 ;
31053 char *kwnames[] = {
31054 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31055 };
31056
31057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31059 if (SWIG_arg_fail(1)) SWIG_fail;
31060 {
31061 arg2 = (int)(SWIG_As_int(obj1));
31062 if (SWIG_arg_fail(2)) SWIG_fail;
31063 }
31064 {
31065 arg3 = (int)(SWIG_As_int(obj2));
31066 if (SWIG_arg_fail(3)) SWIG_fail;
31067 }
31068 {
31069 arg4 = (int)(SWIG_As_int(obj3));
31070 if (SWIG_arg_fail(4)) SWIG_fail;
31071 }
31072 {
31073 arg5 = (int)(SWIG_As_int(obj4));
31074 if (SWIG_arg_fail(5)) SWIG_fail;
31075 }
31076 if (obj5) {
31077 {
31078 arg6 = (bool)(SWIG_As_bool(obj5));
31079 if (SWIG_arg_fail(6)) SWIG_fail;
31080 }
31081 }
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31085
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 Py_INCREF(Py_None); resultobj = Py_None;
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31097 PyObject *resultobj;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 int arg2 ;
31100 int arg3 ;
31101 bool arg4 = (bool) true ;
31102 PyObject * obj0 = 0 ;
31103 PyObject * obj1 = 0 ;
31104 PyObject * obj2 = 0 ;
31105 PyObject * obj3 = 0 ;
31106 char *kwnames[] = {
31107 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31108 };
31109
31110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31112 if (SWIG_arg_fail(1)) SWIG_fail;
31113 {
31114 arg2 = (int)(SWIG_As_int(obj1));
31115 if (SWIG_arg_fail(2)) SWIG_fail;
31116 }
31117 {
31118 arg3 = (int)(SWIG_As_int(obj2));
31119 if (SWIG_arg_fail(3)) SWIG_fail;
31120 }
31121 if (obj3) {
31122 {
31123 arg4 = (bool)(SWIG_As_bool(obj3));
31124 if (SWIG_arg_fail(4)) SWIG_fail;
31125 }
31126 }
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 (arg1)->SetScrollPos(arg2,arg3,arg4);
31130
31131 wxPyEndAllowThreads(__tstate);
31132 if (PyErr_Occurred()) SWIG_fail;
31133 }
31134 Py_INCREF(Py_None); resultobj = Py_None;
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj;
31143 wxWindow *arg1 = (wxWindow *) 0 ;
31144 int arg2 ;
31145 int result;
31146 PyObject * obj0 = 0 ;
31147 PyObject * obj1 = 0 ;
31148 char *kwnames[] = {
31149 (char *) "self",(char *) "orientation", NULL
31150 };
31151
31152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31154 if (SWIG_arg_fail(1)) SWIG_fail;
31155 {
31156 arg2 = (int)(SWIG_As_int(obj1));
31157 if (SWIG_arg_fail(2)) SWIG_fail;
31158 }
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31162
31163 wxPyEndAllowThreads(__tstate);
31164 if (PyErr_Occurred()) SWIG_fail;
31165 }
31166 {
31167 resultobj = SWIG_From_int((int)(result));
31168 }
31169 return resultobj;
31170 fail:
31171 return NULL;
31172 }
31173
31174
31175 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31176 PyObject *resultobj;
31177 wxWindow *arg1 = (wxWindow *) 0 ;
31178 int arg2 ;
31179 int result;
31180 PyObject * obj0 = 0 ;
31181 PyObject * obj1 = 0 ;
31182 char *kwnames[] = {
31183 (char *) "self",(char *) "orientation", NULL
31184 };
31185
31186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31188 if (SWIG_arg_fail(1)) SWIG_fail;
31189 {
31190 arg2 = (int)(SWIG_As_int(obj1));
31191 if (SWIG_arg_fail(2)) SWIG_fail;
31192 }
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31196
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 {
31201 resultobj = SWIG_From_int((int)(result));
31202 }
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj;
31211 wxWindow *arg1 = (wxWindow *) 0 ;
31212 int arg2 ;
31213 int result;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char *kwnames[] = {
31217 (char *) "self",(char *) "orientation", NULL
31218 };
31219
31220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31222 if (SWIG_arg_fail(1)) SWIG_fail;
31223 {
31224 arg2 = (int)(SWIG_As_int(obj1));
31225 if (SWIG_arg_fail(2)) SWIG_fail;
31226 }
31227 {
31228 PyThreadState* __tstate = wxPyBeginAllowThreads();
31229 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31230
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 {
31235 resultobj = SWIG_From_int((int)(result));
31236 }
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31244 PyObject *resultobj;
31245 wxWindow *arg1 = (wxWindow *) 0 ;
31246 int arg2 ;
31247 int arg3 ;
31248 wxRect *arg4 = (wxRect *) NULL ;
31249 PyObject * obj0 = 0 ;
31250 PyObject * obj1 = 0 ;
31251 PyObject * obj2 = 0 ;
31252 PyObject * obj3 = 0 ;
31253 char *kwnames[] = {
31254 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31259 if (SWIG_arg_fail(1)) SWIG_fail;
31260 {
31261 arg2 = (int)(SWIG_As_int(obj1));
31262 if (SWIG_arg_fail(2)) SWIG_fail;
31263 }
31264 {
31265 arg3 = (int)(SWIG_As_int(obj2));
31266 if (SWIG_arg_fail(3)) SWIG_fail;
31267 }
31268 if (obj3) {
31269 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31270 if (SWIG_arg_fail(4)) SWIG_fail;
31271 }
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31275
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 Py_INCREF(Py_None); resultobj = Py_None;
31280 return resultobj;
31281 fail:
31282 return NULL;
31283 }
31284
31285
31286 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31287 PyObject *resultobj;
31288 wxWindow *arg1 = (wxWindow *) 0 ;
31289 int arg2 ;
31290 bool result;
31291 PyObject * obj0 = 0 ;
31292 PyObject * obj1 = 0 ;
31293 char *kwnames[] = {
31294 (char *) "self",(char *) "lines", NULL
31295 };
31296
31297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31299 if (SWIG_arg_fail(1)) SWIG_fail;
31300 {
31301 arg2 = (int)(SWIG_As_int(obj1));
31302 if (SWIG_arg_fail(2)) SWIG_fail;
31303 }
31304 {
31305 PyThreadState* __tstate = wxPyBeginAllowThreads();
31306 result = (bool)(arg1)->ScrollLines(arg2);
31307
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 {
31312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31313 }
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31321 PyObject *resultobj;
31322 wxWindow *arg1 = (wxWindow *) 0 ;
31323 int arg2 ;
31324 bool result;
31325 PyObject * obj0 = 0 ;
31326 PyObject * obj1 = 0 ;
31327 char *kwnames[] = {
31328 (char *) "self",(char *) "pages", NULL
31329 };
31330
31331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31333 if (SWIG_arg_fail(1)) SWIG_fail;
31334 {
31335 arg2 = (int)(SWIG_As_int(obj1));
31336 if (SWIG_arg_fail(2)) SWIG_fail;
31337 }
31338 {
31339 PyThreadState* __tstate = wxPyBeginAllowThreads();
31340 result = (bool)(arg1)->ScrollPages(arg2);
31341
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 {
31346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31347 }
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31355 PyObject *resultobj;
31356 wxWindow *arg1 = (wxWindow *) 0 ;
31357 bool result;
31358 PyObject * obj0 = 0 ;
31359 char *kwnames[] = {
31360 (char *) "self", NULL
31361 };
31362
31363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31365 if (SWIG_arg_fail(1)) SWIG_fail;
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 result = (bool)(arg1)->LineUp();
31369
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 {
31374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31375 }
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj;
31384 wxWindow *arg1 = (wxWindow *) 0 ;
31385 bool result;
31386 PyObject * obj0 = 0 ;
31387 char *kwnames[] = {
31388 (char *) "self", NULL
31389 };
31390
31391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31393 if (SWIG_arg_fail(1)) SWIG_fail;
31394 {
31395 PyThreadState* __tstate = wxPyBeginAllowThreads();
31396 result = (bool)(arg1)->LineDown();
31397
31398 wxPyEndAllowThreads(__tstate);
31399 if (PyErr_Occurred()) SWIG_fail;
31400 }
31401 {
31402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31403 }
31404 return resultobj;
31405 fail:
31406 return NULL;
31407 }
31408
31409
31410 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31411 PyObject *resultobj;
31412 wxWindow *arg1 = (wxWindow *) 0 ;
31413 bool result;
31414 PyObject * obj0 = 0 ;
31415 char *kwnames[] = {
31416 (char *) "self", NULL
31417 };
31418
31419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31421 if (SWIG_arg_fail(1)) SWIG_fail;
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = (bool)(arg1)->PageUp();
31425
31426 wxPyEndAllowThreads(__tstate);
31427 if (PyErr_Occurred()) SWIG_fail;
31428 }
31429 {
31430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31431 }
31432 return resultobj;
31433 fail:
31434 return NULL;
31435 }
31436
31437
31438 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31439 PyObject *resultobj;
31440 wxWindow *arg1 = (wxWindow *) 0 ;
31441 bool result;
31442 PyObject * obj0 = 0 ;
31443 char *kwnames[] = {
31444 (char *) "self", NULL
31445 };
31446
31447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31449 if (SWIG_arg_fail(1)) SWIG_fail;
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = (bool)(arg1)->PageDown();
31453
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 {
31458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31459 }
31460 return resultobj;
31461 fail:
31462 return NULL;
31463 }
31464
31465
31466 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31467 PyObject *resultobj;
31468 wxWindow *arg1 = (wxWindow *) 0 ;
31469 wxString *arg2 = 0 ;
31470 bool temp2 = false ;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 char *kwnames[] = {
31474 (char *) "self",(char *) "text", NULL
31475 };
31476
31477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31479 if (SWIG_arg_fail(1)) SWIG_fail;
31480 {
31481 arg2 = wxString_in_helper(obj1);
31482 if (arg2 == NULL) SWIG_fail;
31483 temp2 = true;
31484 }
31485 {
31486 PyThreadState* __tstate = wxPyBeginAllowThreads();
31487 (arg1)->SetHelpText((wxString const &)*arg2);
31488
31489 wxPyEndAllowThreads(__tstate);
31490 if (PyErr_Occurred()) SWIG_fail;
31491 }
31492 Py_INCREF(Py_None); resultobj = Py_None;
31493 {
31494 if (temp2)
31495 delete arg2;
31496 }
31497 return resultobj;
31498 fail:
31499 {
31500 if (temp2)
31501 delete arg2;
31502 }
31503 return NULL;
31504 }
31505
31506
31507 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31508 PyObject *resultobj;
31509 wxWindow *arg1 = (wxWindow *) 0 ;
31510 wxString *arg2 = 0 ;
31511 bool temp2 = false ;
31512 PyObject * obj0 = 0 ;
31513 PyObject * obj1 = 0 ;
31514 char *kwnames[] = {
31515 (char *) "self",(char *) "text", NULL
31516 };
31517
31518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31520 if (SWIG_arg_fail(1)) SWIG_fail;
31521 {
31522 arg2 = wxString_in_helper(obj1);
31523 if (arg2 == NULL) SWIG_fail;
31524 temp2 = true;
31525 }
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31529
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 Py_INCREF(Py_None); resultobj = Py_None;
31534 {
31535 if (temp2)
31536 delete arg2;
31537 }
31538 return resultobj;
31539 fail:
31540 {
31541 if (temp2)
31542 delete arg2;
31543 }
31544 return NULL;
31545 }
31546
31547
31548 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31549 PyObject *resultobj;
31550 wxWindow *arg1 = (wxWindow *) 0 ;
31551 wxString result;
31552 PyObject * obj0 = 0 ;
31553 char *kwnames[] = {
31554 (char *) "self", NULL
31555 };
31556
31557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31559 if (SWIG_arg_fail(1)) SWIG_fail;
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 result = ((wxWindow const *)arg1)->GetHelpText();
31563
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 {
31568 #if wxUSE_UNICODE
31569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31570 #else
31571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31572 #endif
31573 }
31574 return resultobj;
31575 fail:
31576 return NULL;
31577 }
31578
31579
31580 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31581 PyObject *resultobj;
31582 wxWindow *arg1 = (wxWindow *) 0 ;
31583 wxString *arg2 = 0 ;
31584 bool temp2 = false ;
31585 PyObject * obj0 = 0 ;
31586 PyObject * obj1 = 0 ;
31587 char *kwnames[] = {
31588 (char *) "self",(char *) "tip", NULL
31589 };
31590
31591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31593 if (SWIG_arg_fail(1)) SWIG_fail;
31594 {
31595 arg2 = wxString_in_helper(obj1);
31596 if (arg2 == NULL) SWIG_fail;
31597 temp2 = true;
31598 }
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 (arg1)->SetToolTip((wxString const &)*arg2);
31602
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 Py_INCREF(Py_None); resultobj = Py_None;
31607 {
31608 if (temp2)
31609 delete arg2;
31610 }
31611 return resultobj;
31612 fail:
31613 {
31614 if (temp2)
31615 delete arg2;
31616 }
31617 return NULL;
31618 }
31619
31620
31621 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31622 PyObject *resultobj;
31623 wxWindow *arg1 = (wxWindow *) 0 ;
31624 wxToolTip *arg2 = (wxToolTip *) 0 ;
31625 PyObject * obj0 = 0 ;
31626 PyObject * obj1 = 0 ;
31627 char *kwnames[] = {
31628 (char *) "self",(char *) "tip", NULL
31629 };
31630
31631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31633 if (SWIG_arg_fail(1)) SWIG_fail;
31634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31635 if (SWIG_arg_fail(2)) SWIG_fail;
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 (arg1)->SetToolTip(arg2);
31639
31640 wxPyEndAllowThreads(__tstate);
31641 if (PyErr_Occurred()) SWIG_fail;
31642 }
31643 Py_INCREF(Py_None); resultobj = Py_None;
31644 return resultobj;
31645 fail:
31646 return NULL;
31647 }
31648
31649
31650 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31651 PyObject *resultobj;
31652 wxWindow *arg1 = (wxWindow *) 0 ;
31653 wxToolTip *result;
31654 PyObject * obj0 = 0 ;
31655 char *kwnames[] = {
31656 (char *) "self", NULL
31657 };
31658
31659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31661 if (SWIG_arg_fail(1)) SWIG_fail;
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31665
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 {
31670 resultobj = wxPyMake_wxObject(result, 0);
31671 }
31672 return resultobj;
31673 fail:
31674 return NULL;
31675 }
31676
31677
31678 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31679 PyObject *resultobj;
31680 wxWindow *arg1 = (wxWindow *) 0 ;
31681 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31682 PyObject * obj0 = 0 ;
31683 PyObject * obj1 = 0 ;
31684 char *kwnames[] = {
31685 (char *) "self",(char *) "dropTarget", NULL
31686 };
31687
31688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31690 if (SWIG_arg_fail(1)) SWIG_fail;
31691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31692 if (SWIG_arg_fail(2)) SWIG_fail;
31693 {
31694 PyThreadState* __tstate = wxPyBeginAllowThreads();
31695 (arg1)->SetDropTarget(arg2);
31696
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 Py_INCREF(Py_None); resultobj = Py_None;
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31708 PyObject *resultobj;
31709 wxWindow *arg1 = (wxWindow *) 0 ;
31710 wxPyDropTarget *result;
31711 PyObject * obj0 = 0 ;
31712 char *kwnames[] = {
31713 (char *) "self", NULL
31714 };
31715
31716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31718 if (SWIG_arg_fail(1)) SWIG_fail;
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31722
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31727 return resultobj;
31728 fail:
31729 return NULL;
31730 }
31731
31732
31733 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31734 PyObject *resultobj;
31735 wxWindow *arg1 = (wxWindow *) 0 ;
31736 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31737 PyObject * obj0 = 0 ;
31738 PyObject * obj1 = 0 ;
31739 char *kwnames[] = {
31740 (char *) "self",(char *) "constraints", NULL
31741 };
31742
31743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31745 if (SWIG_arg_fail(1)) SWIG_fail;
31746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31747 if (SWIG_arg_fail(2)) SWIG_fail;
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 (arg1)->SetConstraints(arg2);
31751
31752 wxPyEndAllowThreads(__tstate);
31753 if (PyErr_Occurred()) SWIG_fail;
31754 }
31755 Py_INCREF(Py_None); resultobj = Py_None;
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31763 PyObject *resultobj;
31764 wxWindow *arg1 = (wxWindow *) 0 ;
31765 wxLayoutConstraints *result;
31766 PyObject * obj0 = 0 ;
31767 char *kwnames[] = {
31768 (char *) "self", NULL
31769 };
31770
31771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31773 if (SWIG_arg_fail(1)) SWIG_fail;
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31777
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31789 PyObject *resultobj;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 bool arg2 ;
31792 PyObject * obj0 = 0 ;
31793 PyObject * obj1 = 0 ;
31794 char *kwnames[] = {
31795 (char *) "self",(char *) "autoLayout", NULL
31796 };
31797
31798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31800 if (SWIG_arg_fail(1)) SWIG_fail;
31801 {
31802 arg2 = (bool)(SWIG_As_bool(obj1));
31803 if (SWIG_arg_fail(2)) SWIG_fail;
31804 }
31805 {
31806 PyThreadState* __tstate = wxPyBeginAllowThreads();
31807 (arg1)->SetAutoLayout(arg2);
31808
31809 wxPyEndAllowThreads(__tstate);
31810 if (PyErr_Occurred()) SWIG_fail;
31811 }
31812 Py_INCREF(Py_None); resultobj = Py_None;
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj;
31821 wxWindow *arg1 = (wxWindow *) 0 ;
31822 bool result;
31823 PyObject * obj0 = 0 ;
31824 char *kwnames[] = {
31825 (char *) "self", NULL
31826 };
31827
31828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31830 if (SWIG_arg_fail(1)) SWIG_fail;
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31834
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 {
31839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31840 }
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj;
31849 wxWindow *arg1 = (wxWindow *) 0 ;
31850 bool result;
31851 PyObject * obj0 = 0 ;
31852 char *kwnames[] = {
31853 (char *) "self", NULL
31854 };
31855
31856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31858 if (SWIG_arg_fail(1)) SWIG_fail;
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (bool)(arg1)->Layout();
31862
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 {
31867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31868 }
31869 return resultobj;
31870 fail:
31871 return NULL;
31872 }
31873
31874
31875 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31876 PyObject *resultobj;
31877 wxWindow *arg1 = (wxWindow *) 0 ;
31878 wxSizer *arg2 = (wxSizer *) 0 ;
31879 bool arg3 = (bool) true ;
31880 PyObject * obj0 = 0 ;
31881 PyObject * obj1 = 0 ;
31882 PyObject * obj2 = 0 ;
31883 char *kwnames[] = {
31884 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31885 };
31886
31887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31889 if (SWIG_arg_fail(1)) SWIG_fail;
31890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31891 if (SWIG_arg_fail(2)) SWIG_fail;
31892 if (obj2) {
31893 {
31894 arg3 = (bool)(SWIG_As_bool(obj2));
31895 if (SWIG_arg_fail(3)) SWIG_fail;
31896 }
31897 }
31898 {
31899 PyThreadState* __tstate = wxPyBeginAllowThreads();
31900 (arg1)->SetSizer(arg2,arg3);
31901
31902 wxPyEndAllowThreads(__tstate);
31903 if (PyErr_Occurred()) SWIG_fail;
31904 }
31905 Py_INCREF(Py_None); resultobj = Py_None;
31906 return resultobj;
31907 fail:
31908 return NULL;
31909 }
31910
31911
31912 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31913 PyObject *resultobj;
31914 wxWindow *arg1 = (wxWindow *) 0 ;
31915 wxSizer *arg2 = (wxSizer *) 0 ;
31916 bool arg3 = (bool) true ;
31917 PyObject * obj0 = 0 ;
31918 PyObject * obj1 = 0 ;
31919 PyObject * obj2 = 0 ;
31920 char *kwnames[] = {
31921 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31922 };
31923
31924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31926 if (SWIG_arg_fail(1)) SWIG_fail;
31927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31928 if (SWIG_arg_fail(2)) SWIG_fail;
31929 if (obj2) {
31930 {
31931 arg3 = (bool)(SWIG_As_bool(obj2));
31932 if (SWIG_arg_fail(3)) SWIG_fail;
31933 }
31934 }
31935 {
31936 PyThreadState* __tstate = wxPyBeginAllowThreads();
31937 (arg1)->SetSizerAndFit(arg2,arg3);
31938
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 Py_INCREF(Py_None); resultobj = Py_None;
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31950 PyObject *resultobj;
31951 wxWindow *arg1 = (wxWindow *) 0 ;
31952 wxSizer *result;
31953 PyObject * obj0 = 0 ;
31954 char *kwnames[] = {
31955 (char *) "self", NULL
31956 };
31957
31958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31960 if (SWIG_arg_fail(1)) SWIG_fail;
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31964
31965 wxPyEndAllowThreads(__tstate);
31966 if (PyErr_Occurred()) SWIG_fail;
31967 }
31968 {
31969 resultobj = wxPyMake_wxSizer(result, 0);
31970 }
31971 return resultobj;
31972 fail:
31973 return NULL;
31974 }
31975
31976
31977 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31978 PyObject *resultobj;
31979 wxWindow *arg1 = (wxWindow *) 0 ;
31980 wxSizer *arg2 = (wxSizer *) 0 ;
31981 PyObject * obj0 = 0 ;
31982 PyObject * obj1 = 0 ;
31983 char *kwnames[] = {
31984 (char *) "self",(char *) "sizer", NULL
31985 };
31986
31987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31989 if (SWIG_arg_fail(1)) SWIG_fail;
31990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31991 if (SWIG_arg_fail(2)) SWIG_fail;
31992 {
31993 PyThreadState* __tstate = wxPyBeginAllowThreads();
31994 (arg1)->SetContainingSizer(arg2);
31995
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 Py_INCREF(Py_None); resultobj = Py_None;
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32007 PyObject *resultobj;
32008 wxWindow *arg1 = (wxWindow *) 0 ;
32009 wxSizer *result;
32010 PyObject * obj0 = 0 ;
32011 char *kwnames[] = {
32012 (char *) "self", NULL
32013 };
32014
32015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32017 if (SWIG_arg_fail(1)) SWIG_fail;
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32021
32022 wxPyEndAllowThreads(__tstate);
32023 if (PyErr_Occurred()) SWIG_fail;
32024 }
32025 {
32026 resultobj = wxPyMake_wxSizer(result, 0);
32027 }
32028 return resultobj;
32029 fail:
32030 return NULL;
32031 }
32032
32033
32034 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32035 PyObject *resultobj;
32036 wxWindow *arg1 = (wxWindow *) 0 ;
32037 PyObject * obj0 = 0 ;
32038 char *kwnames[] = {
32039 (char *) "self", NULL
32040 };
32041
32042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32044 if (SWIG_arg_fail(1)) SWIG_fail;
32045 {
32046 PyThreadState* __tstate = wxPyBeginAllowThreads();
32047 (arg1)->InheritAttributes();
32048
32049 wxPyEndAllowThreads(__tstate);
32050 if (PyErr_Occurred()) SWIG_fail;
32051 }
32052 Py_INCREF(Py_None); resultobj = Py_None;
32053 return resultobj;
32054 fail:
32055 return NULL;
32056 }
32057
32058
32059 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32060 PyObject *resultobj;
32061 wxWindow *arg1 = (wxWindow *) 0 ;
32062 bool result;
32063 PyObject * obj0 = 0 ;
32064 char *kwnames[] = {
32065 (char *) "self", NULL
32066 };
32067
32068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32070 if (SWIG_arg_fail(1)) SWIG_fail;
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32074
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 {
32079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32080 }
32081 return resultobj;
32082 fail:
32083 return NULL;
32084 }
32085
32086
32087 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32088 PyObject *obj;
32089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32090 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32091 Py_INCREF(obj);
32092 return Py_BuildValue((char *)"");
32093 }
32094 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32095 PyObject *resultobj;
32096 long arg1 ;
32097 wxWindow *arg2 = (wxWindow *) NULL ;
32098 wxWindow *result;
32099 PyObject * obj0 = 0 ;
32100 PyObject * obj1 = 0 ;
32101 char *kwnames[] = {
32102 (char *) "id",(char *) "parent", NULL
32103 };
32104
32105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32106 {
32107 arg1 = (long)(SWIG_As_long(obj0));
32108 if (SWIG_arg_fail(1)) SWIG_fail;
32109 }
32110 if (obj1) {
32111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32112 if (SWIG_arg_fail(2)) SWIG_fail;
32113 }
32114 {
32115 if (!wxPyCheckForApp()) SWIG_fail;
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32118
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 {
32123 resultobj = wxPyMake_wxObject(result, 0);
32124 }
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32132 PyObject *resultobj;
32133 wxString *arg1 = 0 ;
32134 wxWindow *arg2 = (wxWindow *) NULL ;
32135 wxWindow *result;
32136 bool temp1 = false ;
32137 PyObject * obj0 = 0 ;
32138 PyObject * obj1 = 0 ;
32139 char *kwnames[] = {
32140 (char *) "name",(char *) "parent", NULL
32141 };
32142
32143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32144 {
32145 arg1 = wxString_in_helper(obj0);
32146 if (arg1 == NULL) SWIG_fail;
32147 temp1 = true;
32148 }
32149 if (obj1) {
32150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32151 if (SWIG_arg_fail(2)) SWIG_fail;
32152 }
32153 {
32154 if (!wxPyCheckForApp()) SWIG_fail;
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32157
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 {
32162 resultobj = wxPyMake_wxObject(result, 0);
32163 }
32164 {
32165 if (temp1)
32166 delete arg1;
32167 }
32168 return resultobj;
32169 fail:
32170 {
32171 if (temp1)
32172 delete arg1;
32173 }
32174 return NULL;
32175 }
32176
32177
32178 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32179 PyObject *resultobj;
32180 wxString *arg1 = 0 ;
32181 wxWindow *arg2 = (wxWindow *) NULL ;
32182 wxWindow *result;
32183 bool temp1 = false ;
32184 PyObject * obj0 = 0 ;
32185 PyObject * obj1 = 0 ;
32186 char *kwnames[] = {
32187 (char *) "label",(char *) "parent", NULL
32188 };
32189
32190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32191 {
32192 arg1 = wxString_in_helper(obj0);
32193 if (arg1 == NULL) SWIG_fail;
32194 temp1 = true;
32195 }
32196 if (obj1) {
32197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32198 if (SWIG_arg_fail(2)) SWIG_fail;
32199 }
32200 {
32201 if (!wxPyCheckForApp()) SWIG_fail;
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32204
32205 wxPyEndAllowThreads(__tstate);
32206 if (PyErr_Occurred()) SWIG_fail;
32207 }
32208 {
32209 resultobj = wxPyMake_wxObject(result, 0);
32210 }
32211 {
32212 if (temp1)
32213 delete arg1;
32214 }
32215 return resultobj;
32216 fail:
32217 {
32218 if (temp1)
32219 delete arg1;
32220 }
32221 return NULL;
32222 }
32223
32224
32225 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32226 PyObject *resultobj;
32227 wxWindow *arg1 = (wxWindow *) 0 ;
32228 unsigned long arg2 ;
32229 wxWindow *result;
32230 PyObject * obj0 = 0 ;
32231 PyObject * obj1 = 0 ;
32232 char *kwnames[] = {
32233 (char *) "parent",(char *) "_hWnd", NULL
32234 };
32235
32236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32238 if (SWIG_arg_fail(1)) SWIG_fail;
32239 {
32240 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32241 if (SWIG_arg_fail(2)) SWIG_fail;
32242 }
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32246
32247 wxPyEndAllowThreads(__tstate);
32248 if (PyErr_Occurred()) SWIG_fail;
32249 }
32250 {
32251 resultobj = wxPyMake_wxObject(result, 0);
32252 }
32253 return resultobj;
32254 fail:
32255 return NULL;
32256 }
32257
32258
32259 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj;
32261 PyObject *result;
32262 char *kwnames[] = {
32263 NULL
32264 };
32265
32266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32267 {
32268 PyThreadState* __tstate = wxPyBeginAllowThreads();
32269 result = (PyObject *)GetTopLevelWindows();
32270
32271 wxPyEndAllowThreads(__tstate);
32272 if (PyErr_Occurred()) SWIG_fail;
32273 }
32274 resultobj = result;
32275 return resultobj;
32276 fail:
32277 return NULL;
32278 }
32279
32280
32281 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32282 PyObject *resultobj;
32283 wxValidator *result;
32284 char *kwnames[] = {
32285 NULL
32286 };
32287
32288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (wxValidator *)new wxValidator();
32292
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32304 PyObject *resultobj;
32305 wxValidator *arg1 = (wxValidator *) 0 ;
32306 wxValidator *result;
32307 PyObject * obj0 = 0 ;
32308 char *kwnames[] = {
32309 (char *) "self", NULL
32310 };
32311
32312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32314 if (SWIG_arg_fail(1)) SWIG_fail;
32315 {
32316 PyThreadState* __tstate = wxPyBeginAllowThreads();
32317 result = (wxValidator *)(arg1)->Clone();
32318
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 {
32323 resultobj = wxPyMake_wxObject(result, 0);
32324 }
32325 return resultobj;
32326 fail:
32327 return NULL;
32328 }
32329
32330
32331 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32332 PyObject *resultobj;
32333 wxValidator *arg1 = (wxValidator *) 0 ;
32334 wxWindow *arg2 = (wxWindow *) 0 ;
32335 bool result;
32336 PyObject * obj0 = 0 ;
32337 PyObject * obj1 = 0 ;
32338 char *kwnames[] = {
32339 (char *) "self",(char *) "parent", NULL
32340 };
32341
32342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32344 if (SWIG_arg_fail(1)) SWIG_fail;
32345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32346 if (SWIG_arg_fail(2)) SWIG_fail;
32347 {
32348 PyThreadState* __tstate = wxPyBeginAllowThreads();
32349 result = (bool)(arg1)->Validate(arg2);
32350
32351 wxPyEndAllowThreads(__tstate);
32352 if (PyErr_Occurred()) SWIG_fail;
32353 }
32354 {
32355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32356 }
32357 return resultobj;
32358 fail:
32359 return NULL;
32360 }
32361
32362
32363 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32364 PyObject *resultobj;
32365 wxValidator *arg1 = (wxValidator *) 0 ;
32366 bool result;
32367 PyObject * obj0 = 0 ;
32368 char *kwnames[] = {
32369 (char *) "self", NULL
32370 };
32371
32372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32374 if (SWIG_arg_fail(1)) SWIG_fail;
32375 {
32376 PyThreadState* __tstate = wxPyBeginAllowThreads();
32377 result = (bool)(arg1)->TransferToWindow();
32378
32379 wxPyEndAllowThreads(__tstate);
32380 if (PyErr_Occurred()) SWIG_fail;
32381 }
32382 {
32383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32384 }
32385 return resultobj;
32386 fail:
32387 return NULL;
32388 }
32389
32390
32391 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32392 PyObject *resultobj;
32393 wxValidator *arg1 = (wxValidator *) 0 ;
32394 bool result;
32395 PyObject * obj0 = 0 ;
32396 char *kwnames[] = {
32397 (char *) "self", NULL
32398 };
32399
32400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32402 if (SWIG_arg_fail(1)) SWIG_fail;
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 result = (bool)(arg1)->TransferFromWindow();
32406
32407 wxPyEndAllowThreads(__tstate);
32408 if (PyErr_Occurred()) SWIG_fail;
32409 }
32410 {
32411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32412 }
32413 return resultobj;
32414 fail:
32415 return NULL;
32416 }
32417
32418
32419 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32420 PyObject *resultobj;
32421 wxValidator *arg1 = (wxValidator *) 0 ;
32422 wxWindow *result;
32423 PyObject * obj0 = 0 ;
32424 char *kwnames[] = {
32425 (char *) "self", NULL
32426 };
32427
32428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32430 if (SWIG_arg_fail(1)) SWIG_fail;
32431 {
32432 PyThreadState* __tstate = wxPyBeginAllowThreads();
32433 result = (wxWindow *)(arg1)->GetWindow();
32434
32435 wxPyEndAllowThreads(__tstate);
32436 if (PyErr_Occurred()) SWIG_fail;
32437 }
32438 {
32439 resultobj = wxPyMake_wxObject(result, 0);
32440 }
32441 return resultobj;
32442 fail:
32443 return NULL;
32444 }
32445
32446
32447 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32448 PyObject *resultobj;
32449 wxValidator *arg1 = (wxValidator *) 0 ;
32450 wxWindow *arg2 = (wxWindow *) 0 ;
32451 PyObject * obj0 = 0 ;
32452 PyObject * obj1 = 0 ;
32453 char *kwnames[] = {
32454 (char *) "self",(char *) "window", NULL
32455 };
32456
32457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32459 if (SWIG_arg_fail(1)) SWIG_fail;
32460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32461 if (SWIG_arg_fail(2)) SWIG_fail;
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 (arg1)->SetWindow(arg2);
32465
32466 wxPyEndAllowThreads(__tstate);
32467 if (PyErr_Occurred()) SWIG_fail;
32468 }
32469 Py_INCREF(Py_None); resultobj = Py_None;
32470 return resultobj;
32471 fail:
32472 return NULL;
32473 }
32474
32475
32476 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32477 PyObject *resultobj;
32478 bool result;
32479 char *kwnames[] = {
32480 NULL
32481 };
32482
32483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32484 {
32485 PyThreadState* __tstate = wxPyBeginAllowThreads();
32486 result = (bool)wxValidator::IsSilent();
32487
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 {
32492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32501 PyObject *resultobj;
32502 int arg1 = (int) true ;
32503 PyObject * obj0 = 0 ;
32504 char *kwnames[] = {
32505 (char *) "doIt", NULL
32506 };
32507
32508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32509 if (obj0) {
32510 {
32511 arg1 = (int)(SWIG_As_int(obj0));
32512 if (SWIG_arg_fail(1)) SWIG_fail;
32513 }
32514 }
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 wxValidator::SetBellOnError(arg1);
32518
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 Py_INCREF(Py_None); resultobj = Py_None;
32523 return resultobj;
32524 fail:
32525 return NULL;
32526 }
32527
32528
32529 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32530 PyObject *obj;
32531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32532 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32533 Py_INCREF(obj);
32534 return Py_BuildValue((char *)"");
32535 }
32536 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32537 PyObject *resultobj;
32538 wxPyValidator *result;
32539 char *kwnames[] = {
32540 NULL
32541 };
32542
32543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32544 {
32545 PyThreadState* __tstate = wxPyBeginAllowThreads();
32546 result = (wxPyValidator *)new wxPyValidator();
32547
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32552 return resultobj;
32553 fail:
32554 return NULL;
32555 }
32556
32557
32558 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32559 PyObject *resultobj;
32560 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32561 PyObject *arg2 = (PyObject *) 0 ;
32562 PyObject *arg3 = (PyObject *) 0 ;
32563 int arg4 = (int) true ;
32564 PyObject * obj0 = 0 ;
32565 PyObject * obj1 = 0 ;
32566 PyObject * obj2 = 0 ;
32567 PyObject * obj3 = 0 ;
32568 char *kwnames[] = {
32569 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32570 };
32571
32572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32574 if (SWIG_arg_fail(1)) SWIG_fail;
32575 arg2 = obj1;
32576 arg3 = obj2;
32577 if (obj3) {
32578 {
32579 arg4 = (int)(SWIG_As_int(obj3));
32580 if (SWIG_arg_fail(4)) SWIG_fail;
32581 }
32582 }
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32586
32587 wxPyEndAllowThreads(__tstate);
32588 if (PyErr_Occurred()) SWIG_fail;
32589 }
32590 Py_INCREF(Py_None); resultobj = Py_None;
32591 return resultobj;
32592 fail:
32593 return NULL;
32594 }
32595
32596
32597 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32598 PyObject *obj;
32599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32600 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32601 Py_INCREF(obj);
32602 return Py_BuildValue((char *)"");
32603 }
32604 static int _wrap_DefaultValidator_set(PyObject *) {
32605 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32606 return 1;
32607 }
32608
32609
32610 static PyObject *_wrap_DefaultValidator_get(void) {
32611 PyObject *pyobj;
32612
32613 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32614 return pyobj;
32615 }
32616
32617
32618 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32619 PyObject *resultobj;
32620 wxString const &arg1_defvalue = wxPyEmptyString ;
32621 wxString *arg1 = (wxString *) &arg1_defvalue ;
32622 long arg2 = (long) 0 ;
32623 wxMenu *result;
32624 bool temp1 = false ;
32625 PyObject * obj0 = 0 ;
32626 PyObject * obj1 = 0 ;
32627 char *kwnames[] = {
32628 (char *) "title",(char *) "style", NULL
32629 };
32630
32631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32632 if (obj0) {
32633 {
32634 arg1 = wxString_in_helper(obj0);
32635 if (arg1 == NULL) SWIG_fail;
32636 temp1 = true;
32637 }
32638 }
32639 if (obj1) {
32640 {
32641 arg2 = (long)(SWIG_As_long(obj1));
32642 if (SWIG_arg_fail(2)) SWIG_fail;
32643 }
32644 }
32645 {
32646 if (!wxPyCheckForApp()) SWIG_fail;
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32649
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32654 {
32655 if (temp1)
32656 delete arg1;
32657 }
32658 return resultobj;
32659 fail:
32660 {
32661 if (temp1)
32662 delete arg1;
32663 }
32664 return NULL;
32665 }
32666
32667
32668 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32669 PyObject *resultobj;
32670 wxMenu *arg1 = (wxMenu *) 0 ;
32671 int arg2 ;
32672 wxString *arg3 = 0 ;
32673 wxString const &arg4_defvalue = wxPyEmptyString ;
32674 wxString *arg4 = (wxString *) &arg4_defvalue ;
32675 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32676 wxMenuItem *result;
32677 bool temp3 = false ;
32678 bool temp4 = false ;
32679 PyObject * obj0 = 0 ;
32680 PyObject * obj1 = 0 ;
32681 PyObject * obj2 = 0 ;
32682 PyObject * obj3 = 0 ;
32683 PyObject * obj4 = 0 ;
32684 char *kwnames[] = {
32685 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32686 };
32687
32688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32690 if (SWIG_arg_fail(1)) SWIG_fail;
32691 {
32692 arg2 = (int)(SWIG_As_int(obj1));
32693 if (SWIG_arg_fail(2)) SWIG_fail;
32694 }
32695 {
32696 arg3 = wxString_in_helper(obj2);
32697 if (arg3 == NULL) SWIG_fail;
32698 temp3 = true;
32699 }
32700 if (obj3) {
32701 {
32702 arg4 = wxString_in_helper(obj3);
32703 if (arg4 == NULL) SWIG_fail;
32704 temp4 = true;
32705 }
32706 }
32707 if (obj4) {
32708 {
32709 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32710 if (SWIG_arg_fail(5)) SWIG_fail;
32711 }
32712 }
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32716
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 {
32721 resultobj = wxPyMake_wxObject(result, 0);
32722 }
32723 {
32724 if (temp3)
32725 delete arg3;
32726 }
32727 {
32728 if (temp4)
32729 delete arg4;
32730 }
32731 return resultobj;
32732 fail:
32733 {
32734 if (temp3)
32735 delete arg3;
32736 }
32737 {
32738 if (temp4)
32739 delete arg4;
32740 }
32741 return NULL;
32742 }
32743
32744
32745 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32746 PyObject *resultobj;
32747 wxMenu *arg1 = (wxMenu *) 0 ;
32748 wxMenuItem *result;
32749 PyObject * obj0 = 0 ;
32750 char *kwnames[] = {
32751 (char *) "self", NULL
32752 };
32753
32754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32756 if (SWIG_arg_fail(1)) SWIG_fail;
32757 {
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 result = (wxMenuItem *)(arg1)->AppendSeparator();
32760
32761 wxPyEndAllowThreads(__tstate);
32762 if (PyErr_Occurred()) SWIG_fail;
32763 }
32764 {
32765 resultobj = wxPyMake_wxObject(result, 0);
32766 }
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj;
32775 wxMenu *arg1 = (wxMenu *) 0 ;
32776 int arg2 ;
32777 wxString *arg3 = 0 ;
32778 wxString const &arg4_defvalue = wxPyEmptyString ;
32779 wxString *arg4 = (wxString *) &arg4_defvalue ;
32780 wxMenuItem *result;
32781 bool temp3 = false ;
32782 bool temp4 = false ;
32783 PyObject * obj0 = 0 ;
32784 PyObject * obj1 = 0 ;
32785 PyObject * obj2 = 0 ;
32786 PyObject * obj3 = 0 ;
32787 char *kwnames[] = {
32788 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32789 };
32790
32791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32793 if (SWIG_arg_fail(1)) SWIG_fail;
32794 {
32795 arg2 = (int)(SWIG_As_int(obj1));
32796 if (SWIG_arg_fail(2)) SWIG_fail;
32797 }
32798 {
32799 arg3 = wxString_in_helper(obj2);
32800 if (arg3 == NULL) SWIG_fail;
32801 temp3 = true;
32802 }
32803 if (obj3) {
32804 {
32805 arg4 = wxString_in_helper(obj3);
32806 if (arg4 == NULL) SWIG_fail;
32807 temp4 = true;
32808 }
32809 }
32810 {
32811 PyThreadState* __tstate = wxPyBeginAllowThreads();
32812 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32813
32814 wxPyEndAllowThreads(__tstate);
32815 if (PyErr_Occurred()) SWIG_fail;
32816 }
32817 {
32818 resultobj = wxPyMake_wxObject(result, 0);
32819 }
32820 {
32821 if (temp3)
32822 delete arg3;
32823 }
32824 {
32825 if (temp4)
32826 delete arg4;
32827 }
32828 return resultobj;
32829 fail:
32830 {
32831 if (temp3)
32832 delete arg3;
32833 }
32834 {
32835 if (temp4)
32836 delete arg4;
32837 }
32838 return NULL;
32839 }
32840
32841
32842 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32843 PyObject *resultobj;
32844 wxMenu *arg1 = (wxMenu *) 0 ;
32845 int arg2 ;
32846 wxString *arg3 = 0 ;
32847 wxString const &arg4_defvalue = wxPyEmptyString ;
32848 wxString *arg4 = (wxString *) &arg4_defvalue ;
32849 wxMenuItem *result;
32850 bool temp3 = false ;
32851 bool temp4 = false ;
32852 PyObject * obj0 = 0 ;
32853 PyObject * obj1 = 0 ;
32854 PyObject * obj2 = 0 ;
32855 PyObject * obj3 = 0 ;
32856 char *kwnames[] = {
32857 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32858 };
32859
32860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32862 if (SWIG_arg_fail(1)) SWIG_fail;
32863 {
32864 arg2 = (int)(SWIG_As_int(obj1));
32865 if (SWIG_arg_fail(2)) SWIG_fail;
32866 }
32867 {
32868 arg3 = wxString_in_helper(obj2);
32869 if (arg3 == NULL) SWIG_fail;
32870 temp3 = true;
32871 }
32872 if (obj3) {
32873 {
32874 arg4 = wxString_in_helper(obj3);
32875 if (arg4 == NULL) SWIG_fail;
32876 temp4 = true;
32877 }
32878 }
32879 {
32880 PyThreadState* __tstate = wxPyBeginAllowThreads();
32881 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32882
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 {
32887 resultobj = wxPyMake_wxObject(result, 0);
32888 }
32889 {
32890 if (temp3)
32891 delete arg3;
32892 }
32893 {
32894 if (temp4)
32895 delete arg4;
32896 }
32897 return resultobj;
32898 fail:
32899 {
32900 if (temp3)
32901 delete arg3;
32902 }
32903 {
32904 if (temp4)
32905 delete arg4;
32906 }
32907 return NULL;
32908 }
32909
32910
32911 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32912 PyObject *resultobj;
32913 wxMenu *arg1 = (wxMenu *) 0 ;
32914 int arg2 ;
32915 wxString *arg3 = 0 ;
32916 wxMenu *arg4 = (wxMenu *) 0 ;
32917 wxString const &arg5_defvalue = wxPyEmptyString ;
32918 wxString *arg5 = (wxString *) &arg5_defvalue ;
32919 wxMenuItem *result;
32920 bool temp3 = false ;
32921 bool temp5 = false ;
32922 PyObject * obj0 = 0 ;
32923 PyObject * obj1 = 0 ;
32924 PyObject * obj2 = 0 ;
32925 PyObject * obj3 = 0 ;
32926 PyObject * obj4 = 0 ;
32927 char *kwnames[] = {
32928 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32929 };
32930
32931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32933 if (SWIG_arg_fail(1)) SWIG_fail;
32934 {
32935 arg2 = (int)(SWIG_As_int(obj1));
32936 if (SWIG_arg_fail(2)) SWIG_fail;
32937 }
32938 {
32939 arg3 = wxString_in_helper(obj2);
32940 if (arg3 == NULL) SWIG_fail;
32941 temp3 = true;
32942 }
32943 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32944 if (SWIG_arg_fail(4)) SWIG_fail;
32945 if (obj4) {
32946 {
32947 arg5 = wxString_in_helper(obj4);
32948 if (arg5 == NULL) SWIG_fail;
32949 temp5 = true;
32950 }
32951 }
32952 {
32953 PyThreadState* __tstate = wxPyBeginAllowThreads();
32954 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32955
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 {
32960 resultobj = wxPyMake_wxObject(result, 0);
32961 }
32962 {
32963 if (temp3)
32964 delete arg3;
32965 }
32966 {
32967 if (temp5)
32968 delete arg5;
32969 }
32970 return resultobj;
32971 fail:
32972 {
32973 if (temp3)
32974 delete arg3;
32975 }
32976 {
32977 if (temp5)
32978 delete arg5;
32979 }
32980 return NULL;
32981 }
32982
32983
32984 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32985 PyObject *resultobj;
32986 wxMenu *arg1 = (wxMenu *) 0 ;
32987 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32988 wxMenuItem *result;
32989 PyObject * obj0 = 0 ;
32990 PyObject * obj1 = 0 ;
32991 char *kwnames[] = {
32992 (char *) "self",(char *) "item", NULL
32993 };
32994
32995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32997 if (SWIG_arg_fail(1)) SWIG_fail;
32998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32999 if (SWIG_arg_fail(2)) SWIG_fail;
33000 {
33001 PyThreadState* __tstate = wxPyBeginAllowThreads();
33002 result = (wxMenuItem *)(arg1)->Append(arg2);
33003
33004 wxPyEndAllowThreads(__tstate);
33005 if (PyErr_Occurred()) SWIG_fail;
33006 }
33007 {
33008 resultobj = wxPyMake_wxObject(result, 0);
33009 }
33010 return resultobj;
33011 fail:
33012 return NULL;
33013 }
33014
33015
33016 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33017 PyObject *resultobj;
33018 wxMenu *arg1 = (wxMenu *) 0 ;
33019 PyObject * obj0 = 0 ;
33020 char *kwnames[] = {
33021 (char *) "self", NULL
33022 };
33023
33024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33026 if (SWIG_arg_fail(1)) SWIG_fail;
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 (arg1)->Break();
33030
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 Py_INCREF(Py_None); resultobj = Py_None;
33035 return resultobj;
33036 fail:
33037 return NULL;
33038 }
33039
33040
33041 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33042 PyObject *resultobj;
33043 wxMenu *arg1 = (wxMenu *) 0 ;
33044 size_t arg2 ;
33045 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33046 wxMenuItem *result;
33047 PyObject * obj0 = 0 ;
33048 PyObject * obj1 = 0 ;
33049 PyObject * obj2 = 0 ;
33050 char *kwnames[] = {
33051 (char *) "self",(char *) "pos",(char *) "item", NULL
33052 };
33053
33054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33056 if (SWIG_arg_fail(1)) SWIG_fail;
33057 {
33058 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33059 if (SWIG_arg_fail(2)) SWIG_fail;
33060 }
33061 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33062 if (SWIG_arg_fail(3)) SWIG_fail;
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33066
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 {
33071 resultobj = wxPyMake_wxObject(result, 0);
33072 }
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj;
33081 wxMenu *arg1 = (wxMenu *) 0 ;
33082 size_t arg2 ;
33083 int arg3 ;
33084 wxString *arg4 = 0 ;
33085 wxString const &arg5_defvalue = wxPyEmptyString ;
33086 wxString *arg5 = (wxString *) &arg5_defvalue ;
33087 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33088 wxMenuItem *result;
33089 bool temp4 = false ;
33090 bool temp5 = false ;
33091 PyObject * obj0 = 0 ;
33092 PyObject * obj1 = 0 ;
33093 PyObject * obj2 = 0 ;
33094 PyObject * obj3 = 0 ;
33095 PyObject * obj4 = 0 ;
33096 PyObject * obj5 = 0 ;
33097 char *kwnames[] = {
33098 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33099 };
33100
33101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33103 if (SWIG_arg_fail(1)) SWIG_fail;
33104 {
33105 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33106 if (SWIG_arg_fail(2)) SWIG_fail;
33107 }
33108 {
33109 arg3 = (int)(SWIG_As_int(obj2));
33110 if (SWIG_arg_fail(3)) SWIG_fail;
33111 }
33112 {
33113 arg4 = wxString_in_helper(obj3);
33114 if (arg4 == NULL) SWIG_fail;
33115 temp4 = true;
33116 }
33117 if (obj4) {
33118 {
33119 arg5 = wxString_in_helper(obj4);
33120 if (arg5 == NULL) SWIG_fail;
33121 temp5 = true;
33122 }
33123 }
33124 if (obj5) {
33125 {
33126 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33127 if (SWIG_arg_fail(6)) SWIG_fail;
33128 }
33129 }
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33133
33134 wxPyEndAllowThreads(__tstate);
33135 if (PyErr_Occurred()) SWIG_fail;
33136 }
33137 {
33138 resultobj = wxPyMake_wxObject(result, 0);
33139 }
33140 {
33141 if (temp4)
33142 delete arg4;
33143 }
33144 {
33145 if (temp5)
33146 delete arg5;
33147 }
33148 return resultobj;
33149 fail:
33150 {
33151 if (temp4)
33152 delete arg4;
33153 }
33154 {
33155 if (temp5)
33156 delete arg5;
33157 }
33158 return NULL;
33159 }
33160
33161
33162 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33163 PyObject *resultobj;
33164 wxMenu *arg1 = (wxMenu *) 0 ;
33165 size_t arg2 ;
33166 wxMenuItem *result;
33167 PyObject * obj0 = 0 ;
33168 PyObject * obj1 = 0 ;
33169 char *kwnames[] = {
33170 (char *) "self",(char *) "pos", NULL
33171 };
33172
33173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33175 if (SWIG_arg_fail(1)) SWIG_fail;
33176 {
33177 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33178 if (SWIG_arg_fail(2)) SWIG_fail;
33179 }
33180 {
33181 PyThreadState* __tstate = wxPyBeginAllowThreads();
33182 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33183
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 {
33188 resultobj = wxPyMake_wxObject(result, 0);
33189 }
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33197 PyObject *resultobj;
33198 wxMenu *arg1 = (wxMenu *) 0 ;
33199 size_t arg2 ;
33200 int arg3 ;
33201 wxString *arg4 = 0 ;
33202 wxString const &arg5_defvalue = wxPyEmptyString ;
33203 wxString *arg5 = (wxString *) &arg5_defvalue ;
33204 wxMenuItem *result;
33205 bool temp4 = false ;
33206 bool temp5 = false ;
33207 PyObject * obj0 = 0 ;
33208 PyObject * obj1 = 0 ;
33209 PyObject * obj2 = 0 ;
33210 PyObject * obj3 = 0 ;
33211 PyObject * obj4 = 0 ;
33212 char *kwnames[] = {
33213 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33214 };
33215
33216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 arg3 = (int)(SWIG_As_int(obj2));
33225 if (SWIG_arg_fail(3)) SWIG_fail;
33226 }
33227 {
33228 arg4 = wxString_in_helper(obj3);
33229 if (arg4 == NULL) SWIG_fail;
33230 temp4 = true;
33231 }
33232 if (obj4) {
33233 {
33234 arg5 = wxString_in_helper(obj4);
33235 if (arg5 == NULL) SWIG_fail;
33236 temp5 = true;
33237 }
33238 }
33239 {
33240 PyThreadState* __tstate = wxPyBeginAllowThreads();
33241 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33242
33243 wxPyEndAllowThreads(__tstate);
33244 if (PyErr_Occurred()) SWIG_fail;
33245 }
33246 {
33247 resultobj = wxPyMake_wxObject(result, 0);
33248 }
33249 {
33250 if (temp4)
33251 delete arg4;
33252 }
33253 {
33254 if (temp5)
33255 delete arg5;
33256 }
33257 return resultobj;
33258 fail:
33259 {
33260 if (temp4)
33261 delete arg4;
33262 }
33263 {
33264 if (temp5)
33265 delete arg5;
33266 }
33267 return NULL;
33268 }
33269
33270
33271 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33272 PyObject *resultobj;
33273 wxMenu *arg1 = (wxMenu *) 0 ;
33274 size_t arg2 ;
33275 int arg3 ;
33276 wxString *arg4 = 0 ;
33277 wxString const &arg5_defvalue = wxPyEmptyString ;
33278 wxString *arg5 = (wxString *) &arg5_defvalue ;
33279 wxMenuItem *result;
33280 bool temp4 = false ;
33281 bool temp5 = false ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 PyObject * obj2 = 0 ;
33285 PyObject * obj3 = 0 ;
33286 PyObject * obj4 = 0 ;
33287 char *kwnames[] = {
33288 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33289 };
33290
33291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33293 if (SWIG_arg_fail(1)) SWIG_fail;
33294 {
33295 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33296 if (SWIG_arg_fail(2)) SWIG_fail;
33297 }
33298 {
33299 arg3 = (int)(SWIG_As_int(obj2));
33300 if (SWIG_arg_fail(3)) SWIG_fail;
33301 }
33302 {
33303 arg4 = wxString_in_helper(obj3);
33304 if (arg4 == NULL) SWIG_fail;
33305 temp4 = true;
33306 }
33307 if (obj4) {
33308 {
33309 arg5 = wxString_in_helper(obj4);
33310 if (arg5 == NULL) SWIG_fail;
33311 temp5 = true;
33312 }
33313 }
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33317
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 {
33322 resultobj = wxPyMake_wxObject(result, 0);
33323 }
33324 {
33325 if (temp4)
33326 delete arg4;
33327 }
33328 {
33329 if (temp5)
33330 delete arg5;
33331 }
33332 return resultobj;
33333 fail:
33334 {
33335 if (temp4)
33336 delete arg4;
33337 }
33338 {
33339 if (temp5)
33340 delete arg5;
33341 }
33342 return NULL;
33343 }
33344
33345
33346 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33347 PyObject *resultobj;
33348 wxMenu *arg1 = (wxMenu *) 0 ;
33349 size_t arg2 ;
33350 int arg3 ;
33351 wxString *arg4 = 0 ;
33352 wxMenu *arg5 = (wxMenu *) 0 ;
33353 wxString const &arg6_defvalue = wxPyEmptyString ;
33354 wxString *arg6 = (wxString *) &arg6_defvalue ;
33355 wxMenuItem *result;
33356 bool temp4 = false ;
33357 bool temp6 = false ;
33358 PyObject * obj0 = 0 ;
33359 PyObject * obj1 = 0 ;
33360 PyObject * obj2 = 0 ;
33361 PyObject * obj3 = 0 ;
33362 PyObject * obj4 = 0 ;
33363 PyObject * obj5 = 0 ;
33364 char *kwnames[] = {
33365 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33366 };
33367
33368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33370 if (SWIG_arg_fail(1)) SWIG_fail;
33371 {
33372 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33373 if (SWIG_arg_fail(2)) SWIG_fail;
33374 }
33375 {
33376 arg3 = (int)(SWIG_As_int(obj2));
33377 if (SWIG_arg_fail(3)) SWIG_fail;
33378 }
33379 {
33380 arg4 = wxString_in_helper(obj3);
33381 if (arg4 == NULL) SWIG_fail;
33382 temp4 = true;
33383 }
33384 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33385 if (SWIG_arg_fail(5)) SWIG_fail;
33386 if (obj5) {
33387 {
33388 arg6 = wxString_in_helper(obj5);
33389 if (arg6 == NULL) SWIG_fail;
33390 temp6 = true;
33391 }
33392 }
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33396
33397 wxPyEndAllowThreads(__tstate);
33398 if (PyErr_Occurred()) SWIG_fail;
33399 }
33400 {
33401 resultobj = wxPyMake_wxObject(result, 0);
33402 }
33403 {
33404 if (temp4)
33405 delete arg4;
33406 }
33407 {
33408 if (temp6)
33409 delete arg6;
33410 }
33411 return resultobj;
33412 fail:
33413 {
33414 if (temp4)
33415 delete arg4;
33416 }
33417 {
33418 if (temp6)
33419 delete arg6;
33420 }
33421 return NULL;
33422 }
33423
33424
33425 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33426 PyObject *resultobj;
33427 wxMenu *arg1 = (wxMenu *) 0 ;
33428 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33429 wxMenuItem *result;
33430 PyObject * obj0 = 0 ;
33431 PyObject * obj1 = 0 ;
33432 char *kwnames[] = {
33433 (char *) "self",(char *) "item", NULL
33434 };
33435
33436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33438 if (SWIG_arg_fail(1)) SWIG_fail;
33439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33440 if (SWIG_arg_fail(2)) SWIG_fail;
33441 {
33442 PyThreadState* __tstate = wxPyBeginAllowThreads();
33443 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33444
33445 wxPyEndAllowThreads(__tstate);
33446 if (PyErr_Occurred()) SWIG_fail;
33447 }
33448 {
33449 resultobj = wxPyMake_wxObject(result, 0);
33450 }
33451 return resultobj;
33452 fail:
33453 return NULL;
33454 }
33455
33456
33457 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33458 PyObject *resultobj;
33459 wxMenu *arg1 = (wxMenu *) 0 ;
33460 int arg2 ;
33461 wxString *arg3 = 0 ;
33462 wxString const &arg4_defvalue = wxPyEmptyString ;
33463 wxString *arg4 = (wxString *) &arg4_defvalue ;
33464 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33465 wxMenuItem *result;
33466 bool temp3 = false ;
33467 bool temp4 = false ;
33468 PyObject * obj0 = 0 ;
33469 PyObject * obj1 = 0 ;
33470 PyObject * obj2 = 0 ;
33471 PyObject * obj3 = 0 ;
33472 PyObject * obj4 = 0 ;
33473 char *kwnames[] = {
33474 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33475 };
33476
33477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33479 if (SWIG_arg_fail(1)) SWIG_fail;
33480 {
33481 arg2 = (int)(SWIG_As_int(obj1));
33482 if (SWIG_arg_fail(2)) SWIG_fail;
33483 }
33484 {
33485 arg3 = wxString_in_helper(obj2);
33486 if (arg3 == NULL) SWIG_fail;
33487 temp3 = true;
33488 }
33489 if (obj3) {
33490 {
33491 arg4 = wxString_in_helper(obj3);
33492 if (arg4 == NULL) SWIG_fail;
33493 temp4 = true;
33494 }
33495 }
33496 if (obj4) {
33497 {
33498 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33499 if (SWIG_arg_fail(5)) SWIG_fail;
33500 }
33501 }
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33505
33506 wxPyEndAllowThreads(__tstate);
33507 if (PyErr_Occurred()) SWIG_fail;
33508 }
33509 {
33510 resultobj = wxPyMake_wxObject(result, 0);
33511 }
33512 {
33513 if (temp3)
33514 delete arg3;
33515 }
33516 {
33517 if (temp4)
33518 delete arg4;
33519 }
33520 return resultobj;
33521 fail:
33522 {
33523 if (temp3)
33524 delete arg3;
33525 }
33526 {
33527 if (temp4)
33528 delete arg4;
33529 }
33530 return NULL;
33531 }
33532
33533
33534 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33535 PyObject *resultobj;
33536 wxMenu *arg1 = (wxMenu *) 0 ;
33537 wxMenuItem *result;
33538 PyObject * obj0 = 0 ;
33539 char *kwnames[] = {
33540 (char *) "self", NULL
33541 };
33542
33543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33545 if (SWIG_arg_fail(1)) SWIG_fail;
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 result = (wxMenuItem *)(arg1)->PrependSeparator();
33549
33550 wxPyEndAllowThreads(__tstate);
33551 if (PyErr_Occurred()) SWIG_fail;
33552 }
33553 {
33554 resultobj = wxPyMake_wxObject(result, 0);
33555 }
33556 return resultobj;
33557 fail:
33558 return NULL;
33559 }
33560
33561
33562 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33563 PyObject *resultobj;
33564 wxMenu *arg1 = (wxMenu *) 0 ;
33565 int arg2 ;
33566 wxString *arg3 = 0 ;
33567 wxString const &arg4_defvalue = wxPyEmptyString ;
33568 wxString *arg4 = (wxString *) &arg4_defvalue ;
33569 wxMenuItem *result;
33570 bool temp3 = false ;
33571 bool temp4 = false ;
33572 PyObject * obj0 = 0 ;
33573 PyObject * obj1 = 0 ;
33574 PyObject * obj2 = 0 ;
33575 PyObject * obj3 = 0 ;
33576 char *kwnames[] = {
33577 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33578 };
33579
33580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33582 if (SWIG_arg_fail(1)) SWIG_fail;
33583 {
33584 arg2 = (int)(SWIG_As_int(obj1));
33585 if (SWIG_arg_fail(2)) SWIG_fail;
33586 }
33587 {
33588 arg3 = wxString_in_helper(obj2);
33589 if (arg3 == NULL) SWIG_fail;
33590 temp3 = true;
33591 }
33592 if (obj3) {
33593 {
33594 arg4 = wxString_in_helper(obj3);
33595 if (arg4 == NULL) SWIG_fail;
33596 temp4 = true;
33597 }
33598 }
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33602
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 {
33607 resultobj = wxPyMake_wxObject(result, 0);
33608 }
33609 {
33610 if (temp3)
33611 delete arg3;
33612 }
33613 {
33614 if (temp4)
33615 delete arg4;
33616 }
33617 return resultobj;
33618 fail:
33619 {
33620 if (temp3)
33621 delete arg3;
33622 }
33623 {
33624 if (temp4)
33625 delete arg4;
33626 }
33627 return NULL;
33628 }
33629
33630
33631 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33632 PyObject *resultobj;
33633 wxMenu *arg1 = (wxMenu *) 0 ;
33634 int arg2 ;
33635 wxString *arg3 = 0 ;
33636 wxString const &arg4_defvalue = wxPyEmptyString ;
33637 wxString *arg4 = (wxString *) &arg4_defvalue ;
33638 wxMenuItem *result;
33639 bool temp3 = false ;
33640 bool temp4 = false ;
33641 PyObject * obj0 = 0 ;
33642 PyObject * obj1 = 0 ;
33643 PyObject * obj2 = 0 ;
33644 PyObject * obj3 = 0 ;
33645 char *kwnames[] = {
33646 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33647 };
33648
33649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33651 if (SWIG_arg_fail(1)) SWIG_fail;
33652 {
33653 arg2 = (int)(SWIG_As_int(obj1));
33654 if (SWIG_arg_fail(2)) SWIG_fail;
33655 }
33656 {
33657 arg3 = wxString_in_helper(obj2);
33658 if (arg3 == NULL) SWIG_fail;
33659 temp3 = true;
33660 }
33661 if (obj3) {
33662 {
33663 arg4 = wxString_in_helper(obj3);
33664 if (arg4 == NULL) SWIG_fail;
33665 temp4 = true;
33666 }
33667 }
33668 {
33669 PyThreadState* __tstate = wxPyBeginAllowThreads();
33670 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33671
33672 wxPyEndAllowThreads(__tstate);
33673 if (PyErr_Occurred()) SWIG_fail;
33674 }
33675 {
33676 resultobj = wxPyMake_wxObject(result, 0);
33677 }
33678 {
33679 if (temp3)
33680 delete arg3;
33681 }
33682 {
33683 if (temp4)
33684 delete arg4;
33685 }
33686 return resultobj;
33687 fail:
33688 {
33689 if (temp3)
33690 delete arg3;
33691 }
33692 {
33693 if (temp4)
33694 delete arg4;
33695 }
33696 return NULL;
33697 }
33698
33699
33700 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33701 PyObject *resultobj;
33702 wxMenu *arg1 = (wxMenu *) 0 ;
33703 int arg2 ;
33704 wxString *arg3 = 0 ;
33705 wxMenu *arg4 = (wxMenu *) 0 ;
33706 wxString const &arg5_defvalue = wxPyEmptyString ;
33707 wxString *arg5 = (wxString *) &arg5_defvalue ;
33708 wxMenuItem *result;
33709 bool temp3 = false ;
33710 bool temp5 = false ;
33711 PyObject * obj0 = 0 ;
33712 PyObject * obj1 = 0 ;
33713 PyObject * obj2 = 0 ;
33714 PyObject * obj3 = 0 ;
33715 PyObject * obj4 = 0 ;
33716 char *kwnames[] = {
33717 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33718 };
33719
33720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33722 if (SWIG_arg_fail(1)) SWIG_fail;
33723 {
33724 arg2 = (int)(SWIG_As_int(obj1));
33725 if (SWIG_arg_fail(2)) SWIG_fail;
33726 }
33727 {
33728 arg3 = wxString_in_helper(obj2);
33729 if (arg3 == NULL) SWIG_fail;
33730 temp3 = true;
33731 }
33732 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33733 if (SWIG_arg_fail(4)) SWIG_fail;
33734 if (obj4) {
33735 {
33736 arg5 = wxString_in_helper(obj4);
33737 if (arg5 == NULL) SWIG_fail;
33738 temp5 = true;
33739 }
33740 }
33741 {
33742 PyThreadState* __tstate = wxPyBeginAllowThreads();
33743 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33744
33745 wxPyEndAllowThreads(__tstate);
33746 if (PyErr_Occurred()) SWIG_fail;
33747 }
33748 {
33749 resultobj = wxPyMake_wxObject(result, 0);
33750 }
33751 {
33752 if (temp3)
33753 delete arg3;
33754 }
33755 {
33756 if (temp5)
33757 delete arg5;
33758 }
33759 return resultobj;
33760 fail:
33761 {
33762 if (temp3)
33763 delete arg3;
33764 }
33765 {
33766 if (temp5)
33767 delete arg5;
33768 }
33769 return NULL;
33770 }
33771
33772
33773 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33774 PyObject *resultobj;
33775 wxMenu *arg1 = (wxMenu *) 0 ;
33776 int arg2 ;
33777 wxMenuItem *result;
33778 PyObject * obj0 = 0 ;
33779 PyObject * obj1 = 0 ;
33780 char *kwnames[] = {
33781 (char *) "self",(char *) "id", NULL
33782 };
33783
33784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33786 if (SWIG_arg_fail(1)) SWIG_fail;
33787 {
33788 arg2 = (int)(SWIG_As_int(obj1));
33789 if (SWIG_arg_fail(2)) SWIG_fail;
33790 }
33791 {
33792 PyThreadState* __tstate = wxPyBeginAllowThreads();
33793 result = (wxMenuItem *)(arg1)->Remove(arg2);
33794
33795 wxPyEndAllowThreads(__tstate);
33796 if (PyErr_Occurred()) SWIG_fail;
33797 }
33798 {
33799 resultobj = wxPyMake_wxObject(result, 0);
33800 }
33801 return resultobj;
33802 fail:
33803 return NULL;
33804 }
33805
33806
33807 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33808 PyObject *resultobj;
33809 wxMenu *arg1 = (wxMenu *) 0 ;
33810 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33811 wxMenuItem *result;
33812 PyObject * obj0 = 0 ;
33813 PyObject * obj1 = 0 ;
33814 char *kwnames[] = {
33815 (char *) "self",(char *) "item", NULL
33816 };
33817
33818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33820 if (SWIG_arg_fail(1)) SWIG_fail;
33821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33822 if (SWIG_arg_fail(2)) SWIG_fail;
33823 {
33824 PyThreadState* __tstate = wxPyBeginAllowThreads();
33825 result = (wxMenuItem *)(arg1)->Remove(arg2);
33826
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 {
33831 resultobj = wxPyMake_wxObject(result, 0);
33832 }
33833 return resultobj;
33834 fail:
33835 return NULL;
33836 }
33837
33838
33839 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33840 PyObject *resultobj;
33841 wxMenu *arg1 = (wxMenu *) 0 ;
33842 int arg2 ;
33843 bool result;
33844 PyObject * obj0 = 0 ;
33845 PyObject * obj1 = 0 ;
33846 char *kwnames[] = {
33847 (char *) "self",(char *) "id", NULL
33848 };
33849
33850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33852 if (SWIG_arg_fail(1)) SWIG_fail;
33853 {
33854 arg2 = (int)(SWIG_As_int(obj1));
33855 if (SWIG_arg_fail(2)) SWIG_fail;
33856 }
33857 {
33858 PyThreadState* __tstate = wxPyBeginAllowThreads();
33859 result = (bool)(arg1)->Delete(arg2);
33860
33861 wxPyEndAllowThreads(__tstate);
33862 if (PyErr_Occurred()) SWIG_fail;
33863 }
33864 {
33865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33866 }
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33874 PyObject *resultobj;
33875 wxMenu *arg1 = (wxMenu *) 0 ;
33876 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33877 bool result;
33878 PyObject * obj0 = 0 ;
33879 PyObject * obj1 = 0 ;
33880 char *kwnames[] = {
33881 (char *) "self",(char *) "item", NULL
33882 };
33883
33884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33886 if (SWIG_arg_fail(1)) SWIG_fail;
33887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33888 if (SWIG_arg_fail(2)) SWIG_fail;
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = (bool)(arg1)->Delete(arg2);
33892
33893 wxPyEndAllowThreads(__tstate);
33894 if (PyErr_Occurred()) SWIG_fail;
33895 }
33896 {
33897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33898 }
33899 return resultobj;
33900 fail:
33901 return NULL;
33902 }
33903
33904
33905 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33906 PyObject *resultobj;
33907 wxMenu *arg1 = (wxMenu *) 0 ;
33908 PyObject * obj0 = 0 ;
33909 char *kwnames[] = {
33910 (char *) "self", NULL
33911 };
33912
33913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33915 if (SWIG_arg_fail(1)) SWIG_fail;
33916 {
33917 PyThreadState* __tstate = wxPyBeginAllowThreads();
33918 wxMenu_Destroy(arg1);
33919
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 Py_INCREF(Py_None); resultobj = Py_None;
33924 return resultobj;
33925 fail:
33926 return NULL;
33927 }
33928
33929
33930 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33931 PyObject *resultobj;
33932 wxMenu *arg1 = (wxMenu *) 0 ;
33933 int arg2 ;
33934 bool result;
33935 PyObject * obj0 = 0 ;
33936 PyObject * obj1 = 0 ;
33937 char *kwnames[] = {
33938 (char *) "self",(char *) "id", NULL
33939 };
33940
33941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33943 if (SWIG_arg_fail(1)) SWIG_fail;
33944 {
33945 arg2 = (int)(SWIG_As_int(obj1));
33946 if (SWIG_arg_fail(2)) SWIG_fail;
33947 }
33948 {
33949 PyThreadState* __tstate = wxPyBeginAllowThreads();
33950 result = (bool)(arg1)->Destroy(arg2);
33951
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 {
33956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33957 }
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33965 PyObject *resultobj;
33966 wxMenu *arg1 = (wxMenu *) 0 ;
33967 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33968 bool result;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 char *kwnames[] = {
33972 (char *) "self",(char *) "item", NULL
33973 };
33974
33975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33977 if (SWIG_arg_fail(1)) SWIG_fail;
33978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33979 if (SWIG_arg_fail(2)) SWIG_fail;
33980 {
33981 PyThreadState* __tstate = wxPyBeginAllowThreads();
33982 result = (bool)(arg1)->Destroy(arg2);
33983
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 {
33988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33989 }
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj;
33998 wxMenu *arg1 = (wxMenu *) 0 ;
33999 size_t result;
34000 PyObject * obj0 = 0 ;
34001 char *kwnames[] = {
34002 (char *) "self", NULL
34003 };
34004
34005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34007 if (SWIG_arg_fail(1)) SWIG_fail;
34008 {
34009 PyThreadState* __tstate = wxPyBeginAllowThreads();
34010 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34011
34012 wxPyEndAllowThreads(__tstate);
34013 if (PyErr_Occurred()) SWIG_fail;
34014 }
34015 {
34016 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34017 }
34018 return resultobj;
34019 fail:
34020 return NULL;
34021 }
34022
34023
34024 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34025 PyObject *resultobj;
34026 wxMenu *arg1 = (wxMenu *) 0 ;
34027 PyObject *result;
34028 PyObject * obj0 = 0 ;
34029 char *kwnames[] = {
34030 (char *) "self", NULL
34031 };
34032
34033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34035 if (SWIG_arg_fail(1)) SWIG_fail;
34036 {
34037 PyThreadState* __tstate = wxPyBeginAllowThreads();
34038 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34039
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 resultobj = result;
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34051 PyObject *resultobj;
34052 wxMenu *arg1 = (wxMenu *) 0 ;
34053 wxString *arg2 = 0 ;
34054 int result;
34055 bool temp2 = false ;
34056 PyObject * obj0 = 0 ;
34057 PyObject * obj1 = 0 ;
34058 char *kwnames[] = {
34059 (char *) "self",(char *) "item", NULL
34060 };
34061
34062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34064 if (SWIG_arg_fail(1)) SWIG_fail;
34065 {
34066 arg2 = wxString_in_helper(obj1);
34067 if (arg2 == NULL) SWIG_fail;
34068 temp2 = true;
34069 }
34070 {
34071 PyThreadState* __tstate = wxPyBeginAllowThreads();
34072 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34073
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 {
34078 resultobj = SWIG_From_int((int)(result));
34079 }
34080 {
34081 if (temp2)
34082 delete arg2;
34083 }
34084 return resultobj;
34085 fail:
34086 {
34087 if (temp2)
34088 delete arg2;
34089 }
34090 return NULL;
34091 }
34092
34093
34094 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34095 PyObject *resultobj;
34096 wxMenu *arg1 = (wxMenu *) 0 ;
34097 int arg2 ;
34098 wxMenuItem *result;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char *kwnames[] = {
34102 (char *) "self",(char *) "id", NULL
34103 };
34104
34105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",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 = (int)(SWIG_As_int(obj1));
34110 if (SWIG_arg_fail(2)) SWIG_fail;
34111 }
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34115
34116 wxPyEndAllowThreads(__tstate);
34117 if (PyErr_Occurred()) SWIG_fail;
34118 }
34119 {
34120 resultobj = wxPyMake_wxObject(result, 0);
34121 }
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34129 PyObject *resultobj;
34130 wxMenu *arg1 = (wxMenu *) 0 ;
34131 size_t arg2 ;
34132 wxMenuItem *result;
34133 PyObject * obj0 = 0 ;
34134 PyObject * obj1 = 0 ;
34135 char *kwnames[] = {
34136 (char *) "self",(char *) "position", NULL
34137 };
34138
34139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34141 if (SWIG_arg_fail(1)) SWIG_fail;
34142 {
34143 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34144 if (SWIG_arg_fail(2)) SWIG_fail;
34145 }
34146 {
34147 PyThreadState* __tstate = wxPyBeginAllowThreads();
34148 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34149
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 {
34154 resultobj = wxPyMake_wxObject(result, 0);
34155 }
34156 return resultobj;
34157 fail:
34158 return NULL;
34159 }
34160
34161
34162 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34163 PyObject *resultobj;
34164 wxMenu *arg1 = (wxMenu *) 0 ;
34165 int arg2 ;
34166 bool arg3 ;
34167 PyObject * obj0 = 0 ;
34168 PyObject * obj1 = 0 ;
34169 PyObject * obj2 = 0 ;
34170 char *kwnames[] = {
34171 (char *) "self",(char *) "id",(char *) "enable", NULL
34172 };
34173
34174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34176 if (SWIG_arg_fail(1)) SWIG_fail;
34177 {
34178 arg2 = (int)(SWIG_As_int(obj1));
34179 if (SWIG_arg_fail(2)) SWIG_fail;
34180 }
34181 {
34182 arg3 = (bool)(SWIG_As_bool(obj2));
34183 if (SWIG_arg_fail(3)) SWIG_fail;
34184 }
34185 {
34186 PyThreadState* __tstate = wxPyBeginAllowThreads();
34187 (arg1)->Enable(arg2,arg3);
34188
34189 wxPyEndAllowThreads(__tstate);
34190 if (PyErr_Occurred()) SWIG_fail;
34191 }
34192 Py_INCREF(Py_None); resultobj = Py_None;
34193 return resultobj;
34194 fail:
34195 return NULL;
34196 }
34197
34198
34199 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34200 PyObject *resultobj;
34201 wxMenu *arg1 = (wxMenu *) 0 ;
34202 int arg2 ;
34203 bool result;
34204 PyObject * obj0 = 0 ;
34205 PyObject * obj1 = 0 ;
34206 char *kwnames[] = {
34207 (char *) "self",(char *) "id", NULL
34208 };
34209
34210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34212 if (SWIG_arg_fail(1)) SWIG_fail;
34213 {
34214 arg2 = (int)(SWIG_As_int(obj1));
34215 if (SWIG_arg_fail(2)) SWIG_fail;
34216 }
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34220
34221 wxPyEndAllowThreads(__tstate);
34222 if (PyErr_Occurred()) SWIG_fail;
34223 }
34224 {
34225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34226 }
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34234 PyObject *resultobj;
34235 wxMenu *arg1 = (wxMenu *) 0 ;
34236 int arg2 ;
34237 bool arg3 ;
34238 PyObject * obj0 = 0 ;
34239 PyObject * obj1 = 0 ;
34240 PyObject * obj2 = 0 ;
34241 char *kwnames[] = {
34242 (char *) "self",(char *) "id",(char *) "check", NULL
34243 };
34244
34245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34247 if (SWIG_arg_fail(1)) SWIG_fail;
34248 {
34249 arg2 = (int)(SWIG_As_int(obj1));
34250 if (SWIG_arg_fail(2)) SWIG_fail;
34251 }
34252 {
34253 arg3 = (bool)(SWIG_As_bool(obj2));
34254 if (SWIG_arg_fail(3)) SWIG_fail;
34255 }
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 (arg1)->Check(arg2,arg3);
34259
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 Py_INCREF(Py_None); resultobj = Py_None;
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34271 PyObject *resultobj;
34272 wxMenu *arg1 = (wxMenu *) 0 ;
34273 int arg2 ;
34274 bool result;
34275 PyObject * obj0 = 0 ;
34276 PyObject * obj1 = 0 ;
34277 char *kwnames[] = {
34278 (char *) "self",(char *) "id", NULL
34279 };
34280
34281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34283 if (SWIG_arg_fail(1)) SWIG_fail;
34284 {
34285 arg2 = (int)(SWIG_As_int(obj1));
34286 if (SWIG_arg_fail(2)) SWIG_fail;
34287 }
34288 {
34289 PyThreadState* __tstate = wxPyBeginAllowThreads();
34290 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34291
34292 wxPyEndAllowThreads(__tstate);
34293 if (PyErr_Occurred()) SWIG_fail;
34294 }
34295 {
34296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34297 }
34298 return resultobj;
34299 fail:
34300 return NULL;
34301 }
34302
34303
34304 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34305 PyObject *resultobj;
34306 wxMenu *arg1 = (wxMenu *) 0 ;
34307 int arg2 ;
34308 wxString *arg3 = 0 ;
34309 bool temp3 = false ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 PyObject * obj2 = 0 ;
34313 char *kwnames[] = {
34314 (char *) "self",(char *) "id",(char *) "label", NULL
34315 };
34316
34317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34319 if (SWIG_arg_fail(1)) SWIG_fail;
34320 {
34321 arg2 = (int)(SWIG_As_int(obj1));
34322 if (SWIG_arg_fail(2)) SWIG_fail;
34323 }
34324 {
34325 arg3 = wxString_in_helper(obj2);
34326 if (arg3 == NULL) SWIG_fail;
34327 temp3 = true;
34328 }
34329 {
34330 PyThreadState* __tstate = wxPyBeginAllowThreads();
34331 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34332
34333 wxPyEndAllowThreads(__tstate);
34334 if (PyErr_Occurred()) SWIG_fail;
34335 }
34336 Py_INCREF(Py_None); resultobj = Py_None;
34337 {
34338 if (temp3)
34339 delete arg3;
34340 }
34341 return resultobj;
34342 fail:
34343 {
34344 if (temp3)
34345 delete arg3;
34346 }
34347 return NULL;
34348 }
34349
34350
34351 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34352 PyObject *resultobj;
34353 wxMenu *arg1 = (wxMenu *) 0 ;
34354 int arg2 ;
34355 wxString result;
34356 PyObject * obj0 = 0 ;
34357 PyObject * obj1 = 0 ;
34358 char *kwnames[] = {
34359 (char *) "self",(char *) "id", NULL
34360 };
34361
34362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34364 if (SWIG_arg_fail(1)) SWIG_fail;
34365 {
34366 arg2 = (int)(SWIG_As_int(obj1));
34367 if (SWIG_arg_fail(2)) SWIG_fail;
34368 }
34369 {
34370 PyThreadState* __tstate = wxPyBeginAllowThreads();
34371 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34372
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 {
34377 #if wxUSE_UNICODE
34378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34379 #else
34380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34381 #endif
34382 }
34383 return resultobj;
34384 fail:
34385 return NULL;
34386 }
34387
34388
34389 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34390 PyObject *resultobj;
34391 wxMenu *arg1 = (wxMenu *) 0 ;
34392 int arg2 ;
34393 wxString *arg3 = 0 ;
34394 bool temp3 = false ;
34395 PyObject * obj0 = 0 ;
34396 PyObject * obj1 = 0 ;
34397 PyObject * obj2 = 0 ;
34398 char *kwnames[] = {
34399 (char *) "self",(char *) "id",(char *) "helpString", NULL
34400 };
34401
34402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34404 if (SWIG_arg_fail(1)) SWIG_fail;
34405 {
34406 arg2 = (int)(SWIG_As_int(obj1));
34407 if (SWIG_arg_fail(2)) SWIG_fail;
34408 }
34409 {
34410 arg3 = wxString_in_helper(obj2);
34411 if (arg3 == NULL) SWIG_fail;
34412 temp3 = true;
34413 }
34414 {
34415 PyThreadState* __tstate = wxPyBeginAllowThreads();
34416 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34417
34418 wxPyEndAllowThreads(__tstate);
34419 if (PyErr_Occurred()) SWIG_fail;
34420 }
34421 Py_INCREF(Py_None); resultobj = Py_None;
34422 {
34423 if (temp3)
34424 delete arg3;
34425 }
34426 return resultobj;
34427 fail:
34428 {
34429 if (temp3)
34430 delete arg3;
34431 }
34432 return NULL;
34433 }
34434
34435
34436 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34437 PyObject *resultobj;
34438 wxMenu *arg1 = (wxMenu *) 0 ;
34439 int arg2 ;
34440 wxString result;
34441 PyObject * obj0 = 0 ;
34442 PyObject * obj1 = 0 ;
34443 char *kwnames[] = {
34444 (char *) "self",(char *) "id", NULL
34445 };
34446
34447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34449 if (SWIG_arg_fail(1)) SWIG_fail;
34450 {
34451 arg2 = (int)(SWIG_As_int(obj1));
34452 if (SWIG_arg_fail(2)) SWIG_fail;
34453 }
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34457
34458 wxPyEndAllowThreads(__tstate);
34459 if (PyErr_Occurred()) SWIG_fail;
34460 }
34461 {
34462 #if wxUSE_UNICODE
34463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34464 #else
34465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34466 #endif
34467 }
34468 return resultobj;
34469 fail:
34470 return NULL;
34471 }
34472
34473
34474 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34475 PyObject *resultobj;
34476 wxMenu *arg1 = (wxMenu *) 0 ;
34477 wxString *arg2 = 0 ;
34478 bool temp2 = false ;
34479 PyObject * obj0 = 0 ;
34480 PyObject * obj1 = 0 ;
34481 char *kwnames[] = {
34482 (char *) "self",(char *) "title", NULL
34483 };
34484
34485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34487 if (SWIG_arg_fail(1)) SWIG_fail;
34488 {
34489 arg2 = wxString_in_helper(obj1);
34490 if (arg2 == NULL) SWIG_fail;
34491 temp2 = true;
34492 }
34493 {
34494 PyThreadState* __tstate = wxPyBeginAllowThreads();
34495 (arg1)->SetTitle((wxString const &)*arg2);
34496
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 Py_INCREF(Py_None); resultobj = Py_None;
34501 {
34502 if (temp2)
34503 delete arg2;
34504 }
34505 return resultobj;
34506 fail:
34507 {
34508 if (temp2)
34509 delete arg2;
34510 }
34511 return NULL;
34512 }
34513
34514
34515 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34516 PyObject *resultobj;
34517 wxMenu *arg1 = (wxMenu *) 0 ;
34518 wxString result;
34519 PyObject * obj0 = 0 ;
34520 char *kwnames[] = {
34521 (char *) "self", NULL
34522 };
34523
34524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34526 if (SWIG_arg_fail(1)) SWIG_fail;
34527 {
34528 PyThreadState* __tstate = wxPyBeginAllowThreads();
34529 result = ((wxMenu const *)arg1)->GetTitle();
34530
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 {
34535 #if wxUSE_UNICODE
34536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34537 #else
34538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34539 #endif
34540 }
34541 return resultobj;
34542 fail:
34543 return NULL;
34544 }
34545
34546
34547 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34548 PyObject *resultobj;
34549 wxMenu *arg1 = (wxMenu *) 0 ;
34550 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34551 PyObject * obj0 = 0 ;
34552 PyObject * obj1 = 0 ;
34553 char *kwnames[] = {
34554 (char *) "self",(char *) "handler", NULL
34555 };
34556
34557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34559 if (SWIG_arg_fail(1)) SWIG_fail;
34560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34561 if (SWIG_arg_fail(2)) SWIG_fail;
34562 {
34563 PyThreadState* __tstate = wxPyBeginAllowThreads();
34564 (arg1)->SetEventHandler(arg2);
34565
34566 wxPyEndAllowThreads(__tstate);
34567 if (PyErr_Occurred()) SWIG_fail;
34568 }
34569 Py_INCREF(Py_None); resultobj = Py_None;
34570 return resultobj;
34571 fail:
34572 return NULL;
34573 }
34574
34575
34576 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34577 PyObject *resultobj;
34578 wxMenu *arg1 = (wxMenu *) 0 ;
34579 wxEvtHandler *result;
34580 PyObject * obj0 = 0 ;
34581 char *kwnames[] = {
34582 (char *) "self", NULL
34583 };
34584
34585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34587 if (SWIG_arg_fail(1)) SWIG_fail;
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34591
34592 wxPyEndAllowThreads(__tstate);
34593 if (PyErr_Occurred()) SWIG_fail;
34594 }
34595 {
34596 resultobj = wxPyMake_wxObject(result, 0);
34597 }
34598 return resultobj;
34599 fail:
34600 return NULL;
34601 }
34602
34603
34604 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34605 PyObject *resultobj;
34606 wxMenu *arg1 = (wxMenu *) 0 ;
34607 wxWindow *arg2 = (wxWindow *) 0 ;
34608 PyObject * obj0 = 0 ;
34609 PyObject * obj1 = 0 ;
34610 char *kwnames[] = {
34611 (char *) "self",(char *) "win", NULL
34612 };
34613
34614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34616 if (SWIG_arg_fail(1)) SWIG_fail;
34617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34618 if (SWIG_arg_fail(2)) SWIG_fail;
34619 {
34620 PyThreadState* __tstate = wxPyBeginAllowThreads();
34621 (arg1)->SetInvokingWindow(arg2);
34622
34623 wxPyEndAllowThreads(__tstate);
34624 if (PyErr_Occurred()) SWIG_fail;
34625 }
34626 Py_INCREF(Py_None); resultobj = Py_None;
34627 return resultobj;
34628 fail:
34629 return NULL;
34630 }
34631
34632
34633 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34634 PyObject *resultobj;
34635 wxMenu *arg1 = (wxMenu *) 0 ;
34636 wxWindow *result;
34637 PyObject * obj0 = 0 ;
34638 char *kwnames[] = {
34639 (char *) "self", NULL
34640 };
34641
34642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34644 if (SWIG_arg_fail(1)) SWIG_fail;
34645 {
34646 PyThreadState* __tstate = wxPyBeginAllowThreads();
34647 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34648
34649 wxPyEndAllowThreads(__tstate);
34650 if (PyErr_Occurred()) SWIG_fail;
34651 }
34652 {
34653 resultobj = wxPyMake_wxObject(result, 0);
34654 }
34655 return resultobj;
34656 fail:
34657 return NULL;
34658 }
34659
34660
34661 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34662 PyObject *resultobj;
34663 wxMenu *arg1 = (wxMenu *) 0 ;
34664 long result;
34665 PyObject * obj0 = 0 ;
34666 char *kwnames[] = {
34667 (char *) "self", NULL
34668 };
34669
34670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34672 if (SWIG_arg_fail(1)) SWIG_fail;
34673 {
34674 PyThreadState* __tstate = wxPyBeginAllowThreads();
34675 result = (long)((wxMenu const *)arg1)->GetStyle();
34676
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 {
34681 resultobj = SWIG_From_long((long)(result));
34682 }
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34690 PyObject *resultobj;
34691 wxMenu *arg1 = (wxMenu *) 0 ;
34692 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34693 PyObject * obj0 = 0 ;
34694 PyObject * obj1 = 0 ;
34695 char *kwnames[] = {
34696 (char *) "self",(char *) "source", NULL
34697 };
34698
34699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34701 if (SWIG_arg_fail(1)) SWIG_fail;
34702 if (obj1) {
34703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34704 if (SWIG_arg_fail(2)) SWIG_fail;
34705 }
34706 {
34707 PyThreadState* __tstate = wxPyBeginAllowThreads();
34708 (arg1)->UpdateUI(arg2);
34709
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 Py_INCREF(Py_None); resultobj = Py_None;
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34721 PyObject *resultobj;
34722 wxMenu *arg1 = (wxMenu *) 0 ;
34723 wxMenuBar *result;
34724 PyObject * obj0 = 0 ;
34725 char *kwnames[] = {
34726 (char *) "self", NULL
34727 };
34728
34729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34731 if (SWIG_arg_fail(1)) SWIG_fail;
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34735
34736 wxPyEndAllowThreads(__tstate);
34737 if (PyErr_Occurred()) SWIG_fail;
34738 }
34739 {
34740 resultobj = wxPyMake_wxObject(result, 0);
34741 }
34742 return resultobj;
34743 fail:
34744 return NULL;
34745 }
34746
34747
34748 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34749 PyObject *resultobj;
34750 wxMenu *arg1 = (wxMenu *) 0 ;
34751 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34752 PyObject * obj0 = 0 ;
34753 PyObject * obj1 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "menubar", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34760 if (SWIG_arg_fail(1)) SWIG_fail;
34761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34762 if (SWIG_arg_fail(2)) SWIG_fail;
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 (arg1)->Attach(arg2);
34766
34767 wxPyEndAllowThreads(__tstate);
34768 if (PyErr_Occurred()) SWIG_fail;
34769 }
34770 Py_INCREF(Py_None); resultobj = Py_None;
34771 return resultobj;
34772 fail:
34773 return NULL;
34774 }
34775
34776
34777 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj;
34779 wxMenu *arg1 = (wxMenu *) 0 ;
34780 PyObject * obj0 = 0 ;
34781 char *kwnames[] = {
34782 (char *) "self", NULL
34783 };
34784
34785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34787 if (SWIG_arg_fail(1)) SWIG_fail;
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 (arg1)->Detach();
34791
34792 wxPyEndAllowThreads(__tstate);
34793 if (PyErr_Occurred()) SWIG_fail;
34794 }
34795 Py_INCREF(Py_None); resultobj = Py_None;
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34803 PyObject *resultobj;
34804 wxMenu *arg1 = (wxMenu *) 0 ;
34805 bool result;
34806 PyObject * obj0 = 0 ;
34807 char *kwnames[] = {
34808 (char *) "self", NULL
34809 };
34810
34811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34813 if (SWIG_arg_fail(1)) SWIG_fail;
34814 {
34815 PyThreadState* __tstate = wxPyBeginAllowThreads();
34816 result = (bool)((wxMenu const *)arg1)->IsAttached();
34817
34818 wxPyEndAllowThreads(__tstate);
34819 if (PyErr_Occurred()) SWIG_fail;
34820 }
34821 {
34822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34823 }
34824 return resultobj;
34825 fail:
34826 return NULL;
34827 }
34828
34829
34830 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34831 PyObject *resultobj;
34832 wxMenu *arg1 = (wxMenu *) 0 ;
34833 wxMenu *arg2 = (wxMenu *) 0 ;
34834 PyObject * obj0 = 0 ;
34835 PyObject * obj1 = 0 ;
34836 char *kwnames[] = {
34837 (char *) "self",(char *) "parent", NULL
34838 };
34839
34840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34842 if (SWIG_arg_fail(1)) SWIG_fail;
34843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34844 if (SWIG_arg_fail(2)) SWIG_fail;
34845 {
34846 PyThreadState* __tstate = wxPyBeginAllowThreads();
34847 (arg1)->SetParent(arg2);
34848
34849 wxPyEndAllowThreads(__tstate);
34850 if (PyErr_Occurred()) SWIG_fail;
34851 }
34852 Py_INCREF(Py_None); resultobj = Py_None;
34853 return resultobj;
34854 fail:
34855 return NULL;
34856 }
34857
34858
34859 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34860 PyObject *resultobj;
34861 wxMenu *arg1 = (wxMenu *) 0 ;
34862 wxMenu *result;
34863 PyObject * obj0 = 0 ;
34864 char *kwnames[] = {
34865 (char *) "self", NULL
34866 };
34867
34868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34870 if (SWIG_arg_fail(1)) SWIG_fail;
34871 {
34872 PyThreadState* __tstate = wxPyBeginAllowThreads();
34873 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34874
34875 wxPyEndAllowThreads(__tstate);
34876 if (PyErr_Occurred()) SWIG_fail;
34877 }
34878 {
34879 resultobj = wxPyMake_wxObject(result, 0);
34880 }
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34888 PyObject *obj;
34889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34890 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34891 Py_INCREF(obj);
34892 return Py_BuildValue((char *)"");
34893 }
34894 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34895 PyObject *resultobj;
34896 long arg1 = (long) 0 ;
34897 wxMenuBar *result;
34898 PyObject * obj0 = 0 ;
34899 char *kwnames[] = {
34900 (char *) "style", NULL
34901 };
34902
34903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34904 if (obj0) {
34905 {
34906 arg1 = (long)(SWIG_As_long(obj0));
34907 if (SWIG_arg_fail(1)) SWIG_fail;
34908 }
34909 }
34910 {
34911 if (!wxPyCheckForApp()) SWIG_fail;
34912 PyThreadState* __tstate = wxPyBeginAllowThreads();
34913 result = (wxMenuBar *)new wxMenuBar(arg1);
34914
34915 wxPyEndAllowThreads(__tstate);
34916 if (PyErr_Occurred()) SWIG_fail;
34917 }
34918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34926 PyObject *resultobj;
34927 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34928 wxMenu *arg2 = (wxMenu *) 0 ;
34929 wxString *arg3 = 0 ;
34930 bool result;
34931 bool temp3 = false ;
34932 PyObject * obj0 = 0 ;
34933 PyObject * obj1 = 0 ;
34934 PyObject * obj2 = 0 ;
34935 char *kwnames[] = {
34936 (char *) "self",(char *) "menu",(char *) "title", NULL
34937 };
34938
34939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34941 if (SWIG_arg_fail(1)) SWIG_fail;
34942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34943 if (SWIG_arg_fail(2)) SWIG_fail;
34944 {
34945 arg3 = wxString_in_helper(obj2);
34946 if (arg3 == NULL) SWIG_fail;
34947 temp3 = true;
34948 }
34949 {
34950 PyThreadState* __tstate = wxPyBeginAllowThreads();
34951 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34952
34953 wxPyEndAllowThreads(__tstate);
34954 if (PyErr_Occurred()) SWIG_fail;
34955 }
34956 {
34957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34958 }
34959 {
34960 if (temp3)
34961 delete arg3;
34962 }
34963 return resultobj;
34964 fail:
34965 {
34966 if (temp3)
34967 delete arg3;
34968 }
34969 return NULL;
34970 }
34971
34972
34973 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34974 PyObject *resultobj;
34975 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34976 size_t arg2 ;
34977 wxMenu *arg3 = (wxMenu *) 0 ;
34978 wxString *arg4 = 0 ;
34979 bool result;
34980 bool temp4 = false ;
34981 PyObject * obj0 = 0 ;
34982 PyObject * obj1 = 0 ;
34983 PyObject * obj2 = 0 ;
34984 PyObject * obj3 = 0 ;
34985 char *kwnames[] = {
34986 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34987 };
34988
34989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34991 if (SWIG_arg_fail(1)) SWIG_fail;
34992 {
34993 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34994 if (SWIG_arg_fail(2)) SWIG_fail;
34995 }
34996 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34997 if (SWIG_arg_fail(3)) SWIG_fail;
34998 {
34999 arg4 = wxString_in_helper(obj3);
35000 if (arg4 == NULL) SWIG_fail;
35001 temp4 = true;
35002 }
35003 {
35004 PyThreadState* __tstate = wxPyBeginAllowThreads();
35005 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35006
35007 wxPyEndAllowThreads(__tstate);
35008 if (PyErr_Occurred()) SWIG_fail;
35009 }
35010 {
35011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35012 }
35013 {
35014 if (temp4)
35015 delete arg4;
35016 }
35017 return resultobj;
35018 fail:
35019 {
35020 if (temp4)
35021 delete arg4;
35022 }
35023 return NULL;
35024 }
35025
35026
35027 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35028 PyObject *resultobj;
35029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35030 size_t result;
35031 PyObject * obj0 = 0 ;
35032 char *kwnames[] = {
35033 (char *) "self", NULL
35034 };
35035
35036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35038 if (SWIG_arg_fail(1)) SWIG_fail;
35039 {
35040 PyThreadState* __tstate = wxPyBeginAllowThreads();
35041 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35042
35043 wxPyEndAllowThreads(__tstate);
35044 if (PyErr_Occurred()) SWIG_fail;
35045 }
35046 {
35047 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35048 }
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35056 PyObject *resultobj;
35057 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35058 size_t arg2 ;
35059 wxMenu *result;
35060 PyObject * obj0 = 0 ;
35061 PyObject * obj1 = 0 ;
35062 char *kwnames[] = {
35063 (char *) "self",(char *) "pos", NULL
35064 };
35065
35066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35068 if (SWIG_arg_fail(1)) SWIG_fail;
35069 {
35070 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35071 if (SWIG_arg_fail(2)) SWIG_fail;
35072 }
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35076
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 {
35081 resultobj = wxPyMake_wxObject(result, 0);
35082 }
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35090 PyObject *resultobj;
35091 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35092 size_t arg2 ;
35093 wxMenu *arg3 = (wxMenu *) 0 ;
35094 wxString *arg4 = 0 ;
35095 wxMenu *result;
35096 bool temp4 = false ;
35097 PyObject * obj0 = 0 ;
35098 PyObject * obj1 = 0 ;
35099 PyObject * obj2 = 0 ;
35100 PyObject * obj3 = 0 ;
35101 char *kwnames[] = {
35102 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35103 };
35104
35105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35107 if (SWIG_arg_fail(1)) SWIG_fail;
35108 {
35109 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35110 if (SWIG_arg_fail(2)) SWIG_fail;
35111 }
35112 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35113 if (SWIG_arg_fail(3)) SWIG_fail;
35114 {
35115 arg4 = wxString_in_helper(obj3);
35116 if (arg4 == NULL) SWIG_fail;
35117 temp4 = true;
35118 }
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35122
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 {
35127 resultobj = wxPyMake_wxObject(result, 0);
35128 }
35129 {
35130 if (temp4)
35131 delete arg4;
35132 }
35133 return resultobj;
35134 fail:
35135 {
35136 if (temp4)
35137 delete arg4;
35138 }
35139 return NULL;
35140 }
35141
35142
35143 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35144 PyObject *resultobj;
35145 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35146 size_t arg2 ;
35147 wxMenu *result;
35148 PyObject * obj0 = 0 ;
35149 PyObject * obj1 = 0 ;
35150 char *kwnames[] = {
35151 (char *) "self",(char *) "pos", NULL
35152 };
35153
35154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35156 if (SWIG_arg_fail(1)) SWIG_fail;
35157 {
35158 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35159 if (SWIG_arg_fail(2)) SWIG_fail;
35160 }
35161 {
35162 PyThreadState* __tstate = wxPyBeginAllowThreads();
35163 result = (wxMenu *)(arg1)->Remove(arg2);
35164
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 {
35169 resultobj = wxPyMake_wxObject(result, 0);
35170 }
35171 return resultobj;
35172 fail:
35173 return NULL;
35174 }
35175
35176
35177 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35178 PyObject *resultobj;
35179 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35180 size_t arg2 ;
35181 bool arg3 ;
35182 PyObject * obj0 = 0 ;
35183 PyObject * obj1 = 0 ;
35184 PyObject * obj2 = 0 ;
35185 char *kwnames[] = {
35186 (char *) "self",(char *) "pos",(char *) "enable", NULL
35187 };
35188
35189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35191 if (SWIG_arg_fail(1)) SWIG_fail;
35192 {
35193 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35194 if (SWIG_arg_fail(2)) SWIG_fail;
35195 }
35196 {
35197 arg3 = (bool)(SWIG_As_bool(obj2));
35198 if (SWIG_arg_fail(3)) SWIG_fail;
35199 }
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 (arg1)->EnableTop(arg2,arg3);
35203
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 Py_INCREF(Py_None); resultobj = Py_None;
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35215 PyObject *resultobj;
35216 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35217 size_t arg2 ;
35218 bool result;
35219 PyObject * obj0 = 0 ;
35220 PyObject * obj1 = 0 ;
35221 char *kwnames[] = {
35222 (char *) "self",(char *) "pos", NULL
35223 };
35224
35225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35227 if (SWIG_arg_fail(1)) SWIG_fail;
35228 {
35229 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35230 if (SWIG_arg_fail(2)) SWIG_fail;
35231 }
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35235
35236 wxPyEndAllowThreads(__tstate);
35237 if (PyErr_Occurred()) SWIG_fail;
35238 }
35239 {
35240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35241 }
35242 return resultobj;
35243 fail:
35244 return NULL;
35245 }
35246
35247
35248 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35249 PyObject *resultobj;
35250 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35251 size_t arg2 ;
35252 wxString *arg3 = 0 ;
35253 bool temp3 = false ;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 PyObject * obj2 = 0 ;
35257 char *kwnames[] = {
35258 (char *) "self",(char *) "pos",(char *) "label", NULL
35259 };
35260
35261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35263 if (SWIG_arg_fail(1)) SWIG_fail;
35264 {
35265 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35266 if (SWIG_arg_fail(2)) SWIG_fail;
35267 }
35268 {
35269 arg3 = wxString_in_helper(obj2);
35270 if (arg3 == NULL) SWIG_fail;
35271 temp3 = true;
35272 }
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35276
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 Py_INCREF(Py_None); resultobj = Py_None;
35281 {
35282 if (temp3)
35283 delete arg3;
35284 }
35285 return resultobj;
35286 fail:
35287 {
35288 if (temp3)
35289 delete arg3;
35290 }
35291 return NULL;
35292 }
35293
35294
35295 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35296 PyObject *resultobj;
35297 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35298 size_t arg2 ;
35299 wxString result;
35300 PyObject * obj0 = 0 ;
35301 PyObject * obj1 = 0 ;
35302 char *kwnames[] = {
35303 (char *) "self",(char *) "pos", NULL
35304 };
35305
35306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35308 if (SWIG_arg_fail(1)) SWIG_fail;
35309 {
35310 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35311 if (SWIG_arg_fail(2)) SWIG_fail;
35312 }
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35316
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 {
35321 #if wxUSE_UNICODE
35322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35323 #else
35324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35325 #endif
35326 }
35327 return resultobj;
35328 fail:
35329 return NULL;
35330 }
35331
35332
35333 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35334 PyObject *resultobj;
35335 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35336 wxString *arg2 = 0 ;
35337 wxString *arg3 = 0 ;
35338 int result;
35339 bool temp2 = false ;
35340 bool temp3 = false ;
35341 PyObject * obj0 = 0 ;
35342 PyObject * obj1 = 0 ;
35343 PyObject * obj2 = 0 ;
35344 char *kwnames[] = {
35345 (char *) "self",(char *) "menu",(char *) "item", NULL
35346 };
35347
35348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35350 if (SWIG_arg_fail(1)) SWIG_fail;
35351 {
35352 arg2 = wxString_in_helper(obj1);
35353 if (arg2 == NULL) SWIG_fail;
35354 temp2 = true;
35355 }
35356 {
35357 arg3 = wxString_in_helper(obj2);
35358 if (arg3 == NULL) SWIG_fail;
35359 temp3 = true;
35360 }
35361 {
35362 PyThreadState* __tstate = wxPyBeginAllowThreads();
35363 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35364
35365 wxPyEndAllowThreads(__tstate);
35366 if (PyErr_Occurred()) SWIG_fail;
35367 }
35368 {
35369 resultobj = SWIG_From_int((int)(result));
35370 }
35371 {
35372 if (temp2)
35373 delete arg2;
35374 }
35375 {
35376 if (temp3)
35377 delete arg3;
35378 }
35379 return resultobj;
35380 fail:
35381 {
35382 if (temp2)
35383 delete arg2;
35384 }
35385 {
35386 if (temp3)
35387 delete arg3;
35388 }
35389 return NULL;
35390 }
35391
35392
35393 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35394 PyObject *resultobj;
35395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35396 int arg2 ;
35397 wxMenuItem *result;
35398 PyObject * obj0 = 0 ;
35399 PyObject * obj1 = 0 ;
35400 char *kwnames[] = {
35401 (char *) "self",(char *) "id", NULL
35402 };
35403
35404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35406 if (SWIG_arg_fail(1)) SWIG_fail;
35407 {
35408 arg2 = (int)(SWIG_As_int(obj1));
35409 if (SWIG_arg_fail(2)) SWIG_fail;
35410 }
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35414
35415 wxPyEndAllowThreads(__tstate);
35416 if (PyErr_Occurred()) SWIG_fail;
35417 }
35418 {
35419 resultobj = wxPyMake_wxObject(result, 0);
35420 }
35421 return resultobj;
35422 fail:
35423 return NULL;
35424 }
35425
35426
35427 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35428 PyObject *resultobj;
35429 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35430 wxString *arg2 = 0 ;
35431 int result;
35432 bool temp2 = false ;
35433 PyObject * obj0 = 0 ;
35434 PyObject * obj1 = 0 ;
35435 char *kwnames[] = {
35436 (char *) "self",(char *) "title", NULL
35437 };
35438
35439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35441 if (SWIG_arg_fail(1)) SWIG_fail;
35442 {
35443 arg2 = wxString_in_helper(obj1);
35444 if (arg2 == NULL) SWIG_fail;
35445 temp2 = true;
35446 }
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35450
35451 wxPyEndAllowThreads(__tstate);
35452 if (PyErr_Occurred()) SWIG_fail;
35453 }
35454 {
35455 resultobj = SWIG_From_int((int)(result));
35456 }
35457 {
35458 if (temp2)
35459 delete arg2;
35460 }
35461 return resultobj;
35462 fail:
35463 {
35464 if (temp2)
35465 delete arg2;
35466 }
35467 return NULL;
35468 }
35469
35470
35471 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35472 PyObject *resultobj;
35473 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35474 int arg2 ;
35475 bool arg3 ;
35476 PyObject * obj0 = 0 ;
35477 PyObject * obj1 = 0 ;
35478 PyObject * obj2 = 0 ;
35479 char *kwnames[] = {
35480 (char *) "self",(char *) "id",(char *) "enable", NULL
35481 };
35482
35483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35485 if (SWIG_arg_fail(1)) SWIG_fail;
35486 {
35487 arg2 = (int)(SWIG_As_int(obj1));
35488 if (SWIG_arg_fail(2)) SWIG_fail;
35489 }
35490 {
35491 arg3 = (bool)(SWIG_As_bool(obj2));
35492 if (SWIG_arg_fail(3)) SWIG_fail;
35493 }
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 (arg1)->Enable(arg2,arg3);
35497
35498 wxPyEndAllowThreads(__tstate);
35499 if (PyErr_Occurred()) SWIG_fail;
35500 }
35501 Py_INCREF(Py_None); resultobj = Py_None;
35502 return resultobj;
35503 fail:
35504 return NULL;
35505 }
35506
35507
35508 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35509 PyObject *resultobj;
35510 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35511 int arg2 ;
35512 bool arg3 ;
35513 PyObject * obj0 = 0 ;
35514 PyObject * obj1 = 0 ;
35515 PyObject * obj2 = 0 ;
35516 char *kwnames[] = {
35517 (char *) "self",(char *) "id",(char *) "check", NULL
35518 };
35519
35520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35522 if (SWIG_arg_fail(1)) SWIG_fail;
35523 {
35524 arg2 = (int)(SWIG_As_int(obj1));
35525 if (SWIG_arg_fail(2)) SWIG_fail;
35526 }
35527 {
35528 arg3 = (bool)(SWIG_As_bool(obj2));
35529 if (SWIG_arg_fail(3)) SWIG_fail;
35530 }
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 (arg1)->Check(arg2,arg3);
35534
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 Py_INCREF(Py_None); resultobj = Py_None;
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj;
35547 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35548 int arg2 ;
35549 bool result;
35550 PyObject * obj0 = 0 ;
35551 PyObject * obj1 = 0 ;
35552 char *kwnames[] = {
35553 (char *) "self",(char *) "id", NULL
35554 };
35555
35556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35558 if (SWIG_arg_fail(1)) SWIG_fail;
35559 {
35560 arg2 = (int)(SWIG_As_int(obj1));
35561 if (SWIG_arg_fail(2)) SWIG_fail;
35562 }
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35566
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 {
35571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35572 }
35573 return resultobj;
35574 fail:
35575 return NULL;
35576 }
35577
35578
35579 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35580 PyObject *resultobj;
35581 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35582 int arg2 ;
35583 bool result;
35584 PyObject * obj0 = 0 ;
35585 PyObject * obj1 = 0 ;
35586 char *kwnames[] = {
35587 (char *) "self",(char *) "id", NULL
35588 };
35589
35590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35592 if (SWIG_arg_fail(1)) SWIG_fail;
35593 {
35594 arg2 = (int)(SWIG_As_int(obj1));
35595 if (SWIG_arg_fail(2)) SWIG_fail;
35596 }
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35600
35601 wxPyEndAllowThreads(__tstate);
35602 if (PyErr_Occurred()) SWIG_fail;
35603 }
35604 {
35605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35606 }
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35614 PyObject *resultobj;
35615 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35616 int arg2 ;
35617 wxString *arg3 = 0 ;
35618 bool temp3 = false ;
35619 PyObject * obj0 = 0 ;
35620 PyObject * obj1 = 0 ;
35621 PyObject * obj2 = 0 ;
35622 char *kwnames[] = {
35623 (char *) "self",(char *) "id",(char *) "label", NULL
35624 };
35625
35626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35628 if (SWIG_arg_fail(1)) SWIG_fail;
35629 {
35630 arg2 = (int)(SWIG_As_int(obj1));
35631 if (SWIG_arg_fail(2)) SWIG_fail;
35632 }
35633 {
35634 arg3 = wxString_in_helper(obj2);
35635 if (arg3 == NULL) SWIG_fail;
35636 temp3 = true;
35637 }
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35641
35642 wxPyEndAllowThreads(__tstate);
35643 if (PyErr_Occurred()) SWIG_fail;
35644 }
35645 Py_INCREF(Py_None); resultobj = Py_None;
35646 {
35647 if (temp3)
35648 delete arg3;
35649 }
35650 return resultobj;
35651 fail:
35652 {
35653 if (temp3)
35654 delete arg3;
35655 }
35656 return NULL;
35657 }
35658
35659
35660 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35661 PyObject *resultobj;
35662 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35663 int arg2 ;
35664 wxString result;
35665 PyObject * obj0 = 0 ;
35666 PyObject * obj1 = 0 ;
35667 char *kwnames[] = {
35668 (char *) "self",(char *) "id", NULL
35669 };
35670
35671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35673 if (SWIG_arg_fail(1)) SWIG_fail;
35674 {
35675 arg2 = (int)(SWIG_As_int(obj1));
35676 if (SWIG_arg_fail(2)) SWIG_fail;
35677 }
35678 {
35679 PyThreadState* __tstate = wxPyBeginAllowThreads();
35680 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35681
35682 wxPyEndAllowThreads(__tstate);
35683 if (PyErr_Occurred()) SWIG_fail;
35684 }
35685 {
35686 #if wxUSE_UNICODE
35687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35688 #else
35689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35690 #endif
35691 }
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35699 PyObject *resultobj;
35700 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35701 int arg2 ;
35702 wxString *arg3 = 0 ;
35703 bool temp3 = false ;
35704 PyObject * obj0 = 0 ;
35705 PyObject * obj1 = 0 ;
35706 PyObject * obj2 = 0 ;
35707 char *kwnames[] = {
35708 (char *) "self",(char *) "id",(char *) "helpString", NULL
35709 };
35710
35711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35713 if (SWIG_arg_fail(1)) SWIG_fail;
35714 {
35715 arg2 = (int)(SWIG_As_int(obj1));
35716 if (SWIG_arg_fail(2)) SWIG_fail;
35717 }
35718 {
35719 arg3 = wxString_in_helper(obj2);
35720 if (arg3 == NULL) SWIG_fail;
35721 temp3 = true;
35722 }
35723 {
35724 PyThreadState* __tstate = wxPyBeginAllowThreads();
35725 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35726
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 Py_INCREF(Py_None); resultobj = Py_None;
35731 {
35732 if (temp3)
35733 delete arg3;
35734 }
35735 return resultobj;
35736 fail:
35737 {
35738 if (temp3)
35739 delete arg3;
35740 }
35741 return NULL;
35742 }
35743
35744
35745 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35746 PyObject *resultobj;
35747 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35748 int arg2 ;
35749 wxString result;
35750 PyObject * obj0 = 0 ;
35751 PyObject * obj1 = 0 ;
35752 char *kwnames[] = {
35753 (char *) "self",(char *) "id", NULL
35754 };
35755
35756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35758 if (SWIG_arg_fail(1)) SWIG_fail;
35759 {
35760 arg2 = (int)(SWIG_As_int(obj1));
35761 if (SWIG_arg_fail(2)) SWIG_fail;
35762 }
35763 {
35764 PyThreadState* __tstate = wxPyBeginAllowThreads();
35765 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35766
35767 wxPyEndAllowThreads(__tstate);
35768 if (PyErr_Occurred()) SWIG_fail;
35769 }
35770 {
35771 #if wxUSE_UNICODE
35772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35773 #else
35774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35775 #endif
35776 }
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35784 PyObject *resultobj;
35785 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35786 wxFrame *result;
35787 PyObject * obj0 = 0 ;
35788 char *kwnames[] = {
35789 (char *) "self", NULL
35790 };
35791
35792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35794 if (SWIG_arg_fail(1)) SWIG_fail;
35795 {
35796 PyThreadState* __tstate = wxPyBeginAllowThreads();
35797 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35798
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 {
35803 resultobj = wxPyMake_wxObject(result, 0);
35804 }
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35812 PyObject *resultobj;
35813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35814 bool result;
35815 PyObject * obj0 = 0 ;
35816 char *kwnames[] = {
35817 (char *) "self", NULL
35818 };
35819
35820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35822 if (SWIG_arg_fail(1)) SWIG_fail;
35823 {
35824 PyThreadState* __tstate = wxPyBeginAllowThreads();
35825 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35826
35827 wxPyEndAllowThreads(__tstate);
35828 if (PyErr_Occurred()) SWIG_fail;
35829 }
35830 {
35831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35832 }
35833 return resultobj;
35834 fail:
35835 return NULL;
35836 }
35837
35838
35839 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35840 PyObject *resultobj;
35841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35842 wxFrame *arg2 = (wxFrame *) 0 ;
35843 PyObject * obj0 = 0 ;
35844 PyObject * obj1 = 0 ;
35845 char *kwnames[] = {
35846 (char *) "self",(char *) "frame", NULL
35847 };
35848
35849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(1)) SWIG_fail;
35852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35853 if (SWIG_arg_fail(2)) SWIG_fail;
35854 {
35855 PyThreadState* __tstate = wxPyBeginAllowThreads();
35856 (arg1)->Attach(arg2);
35857
35858 wxPyEndAllowThreads(__tstate);
35859 if (PyErr_Occurred()) SWIG_fail;
35860 }
35861 Py_INCREF(Py_None); resultobj = Py_None;
35862 return resultobj;
35863 fail:
35864 return NULL;
35865 }
35866
35867
35868 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35869 PyObject *resultobj;
35870 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35871 PyObject * obj0 = 0 ;
35872 char *kwnames[] = {
35873 (char *) "self", NULL
35874 };
35875
35876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35878 if (SWIG_arg_fail(1)) SWIG_fail;
35879 {
35880 PyThreadState* __tstate = wxPyBeginAllowThreads();
35881 (arg1)->Detach();
35882
35883 wxPyEndAllowThreads(__tstate);
35884 if (PyErr_Occurred()) SWIG_fail;
35885 }
35886 Py_INCREF(Py_None); resultobj = Py_None;
35887 return resultobj;
35888 fail:
35889 return NULL;
35890 }
35891
35892
35893 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35894 PyObject *obj;
35895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35896 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35897 Py_INCREF(obj);
35898 return Py_BuildValue((char *)"");
35899 }
35900 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35901 PyObject *resultobj;
35902 wxMenu *arg1 = (wxMenu *) NULL ;
35903 int arg2 = (int) wxID_ANY ;
35904 wxString const &arg3_defvalue = wxPyEmptyString ;
35905 wxString *arg3 = (wxString *) &arg3_defvalue ;
35906 wxString const &arg4_defvalue = wxPyEmptyString ;
35907 wxString *arg4 = (wxString *) &arg4_defvalue ;
35908 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35909 wxMenu *arg6 = (wxMenu *) NULL ;
35910 wxMenuItem *result;
35911 bool temp3 = false ;
35912 bool temp4 = false ;
35913 PyObject * obj0 = 0 ;
35914 PyObject * obj1 = 0 ;
35915 PyObject * obj2 = 0 ;
35916 PyObject * obj3 = 0 ;
35917 PyObject * obj4 = 0 ;
35918 PyObject * obj5 = 0 ;
35919 char *kwnames[] = {
35920 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35921 };
35922
35923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35924 if (obj0) {
35925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35926 if (SWIG_arg_fail(1)) SWIG_fail;
35927 }
35928 if (obj1) {
35929 {
35930 arg2 = (int)(SWIG_As_int(obj1));
35931 if (SWIG_arg_fail(2)) SWIG_fail;
35932 }
35933 }
35934 if (obj2) {
35935 {
35936 arg3 = wxString_in_helper(obj2);
35937 if (arg3 == NULL) SWIG_fail;
35938 temp3 = true;
35939 }
35940 }
35941 if (obj3) {
35942 {
35943 arg4 = wxString_in_helper(obj3);
35944 if (arg4 == NULL) SWIG_fail;
35945 temp4 = true;
35946 }
35947 }
35948 if (obj4) {
35949 {
35950 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35951 if (SWIG_arg_fail(5)) SWIG_fail;
35952 }
35953 }
35954 if (obj5) {
35955 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35956 if (SWIG_arg_fail(6)) SWIG_fail;
35957 }
35958 {
35959 PyThreadState* __tstate = wxPyBeginAllowThreads();
35960 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35961
35962 wxPyEndAllowThreads(__tstate);
35963 if (PyErr_Occurred()) SWIG_fail;
35964 }
35965 {
35966 resultobj = wxPyMake_wxObject(result, 1);
35967 }
35968 {
35969 if (temp3)
35970 delete arg3;
35971 }
35972 {
35973 if (temp4)
35974 delete arg4;
35975 }
35976 return resultobj;
35977 fail:
35978 {
35979 if (temp3)
35980 delete arg3;
35981 }
35982 {
35983 if (temp4)
35984 delete arg4;
35985 }
35986 return NULL;
35987 }
35988
35989
35990 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35991 PyObject *resultobj;
35992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35993 wxMenu *result;
35994 PyObject * obj0 = 0 ;
35995 char *kwnames[] = {
35996 (char *) "self", NULL
35997 };
35998
35999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36001 if (SWIG_arg_fail(1)) SWIG_fail;
36002 {
36003 PyThreadState* __tstate = wxPyBeginAllowThreads();
36004 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36005
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 {
36010 resultobj = wxPyMake_wxObject(result, 0);
36011 }
36012 return resultobj;
36013 fail:
36014 return NULL;
36015 }
36016
36017
36018 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36019 PyObject *resultobj;
36020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36021 wxMenu *arg2 = (wxMenu *) 0 ;
36022 PyObject * obj0 = 0 ;
36023 PyObject * obj1 = 0 ;
36024 char *kwnames[] = {
36025 (char *) "self",(char *) "menu", NULL
36026 };
36027
36028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36030 if (SWIG_arg_fail(1)) SWIG_fail;
36031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36032 if (SWIG_arg_fail(2)) SWIG_fail;
36033 {
36034 PyThreadState* __tstate = wxPyBeginAllowThreads();
36035 (arg1)->SetMenu(arg2);
36036
36037 wxPyEndAllowThreads(__tstate);
36038 if (PyErr_Occurred()) SWIG_fail;
36039 }
36040 Py_INCREF(Py_None); resultobj = Py_None;
36041 return resultobj;
36042 fail:
36043 return NULL;
36044 }
36045
36046
36047 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36048 PyObject *resultobj;
36049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36050 int arg2 ;
36051 PyObject * obj0 = 0 ;
36052 PyObject * obj1 = 0 ;
36053 char *kwnames[] = {
36054 (char *) "self",(char *) "id", NULL
36055 };
36056
36057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36059 if (SWIG_arg_fail(1)) SWIG_fail;
36060 {
36061 arg2 = (int)(SWIG_As_int(obj1));
36062 if (SWIG_arg_fail(2)) SWIG_fail;
36063 }
36064 {
36065 PyThreadState* __tstate = wxPyBeginAllowThreads();
36066 (arg1)->SetId(arg2);
36067
36068 wxPyEndAllowThreads(__tstate);
36069 if (PyErr_Occurred()) SWIG_fail;
36070 }
36071 Py_INCREF(Py_None); resultobj = Py_None;
36072 return resultobj;
36073 fail:
36074 return NULL;
36075 }
36076
36077
36078 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36079 PyObject *resultobj;
36080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36081 int result;
36082 PyObject * obj0 = 0 ;
36083 char *kwnames[] = {
36084 (char *) "self", NULL
36085 };
36086
36087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36089 if (SWIG_arg_fail(1)) SWIG_fail;
36090 {
36091 PyThreadState* __tstate = wxPyBeginAllowThreads();
36092 result = (int)((wxMenuItem const *)arg1)->GetId();
36093
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 {
36098 resultobj = SWIG_From_int((int)(result));
36099 }
36100 return resultobj;
36101 fail:
36102 return NULL;
36103 }
36104
36105
36106 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36107 PyObject *resultobj;
36108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36109 bool result;
36110 PyObject * obj0 = 0 ;
36111 char *kwnames[] = {
36112 (char *) "self", NULL
36113 };
36114
36115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36117 if (SWIG_arg_fail(1)) SWIG_fail;
36118 {
36119 PyThreadState* __tstate = wxPyBeginAllowThreads();
36120 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36121
36122 wxPyEndAllowThreads(__tstate);
36123 if (PyErr_Occurred()) SWIG_fail;
36124 }
36125 {
36126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36127 }
36128 return resultobj;
36129 fail:
36130 return NULL;
36131 }
36132
36133
36134 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36135 PyObject *resultobj;
36136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36137 wxString *arg2 = 0 ;
36138 bool temp2 = false ;
36139 PyObject * obj0 = 0 ;
36140 PyObject * obj1 = 0 ;
36141 char *kwnames[] = {
36142 (char *) "self",(char *) "str", NULL
36143 };
36144
36145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36147 if (SWIG_arg_fail(1)) SWIG_fail;
36148 {
36149 arg2 = wxString_in_helper(obj1);
36150 if (arg2 == NULL) SWIG_fail;
36151 temp2 = true;
36152 }
36153 {
36154 PyThreadState* __tstate = wxPyBeginAllowThreads();
36155 (arg1)->SetText((wxString const &)*arg2);
36156
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 Py_INCREF(Py_None); resultobj = Py_None;
36161 {
36162 if (temp2)
36163 delete arg2;
36164 }
36165 return resultobj;
36166 fail:
36167 {
36168 if (temp2)
36169 delete arg2;
36170 }
36171 return NULL;
36172 }
36173
36174
36175 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36176 PyObject *resultobj;
36177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36178 wxString result;
36179 PyObject * obj0 = 0 ;
36180 char *kwnames[] = {
36181 (char *) "self", NULL
36182 };
36183
36184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36186 if (SWIG_arg_fail(1)) SWIG_fail;
36187 {
36188 PyThreadState* __tstate = wxPyBeginAllowThreads();
36189 result = ((wxMenuItem const *)arg1)->GetLabel();
36190
36191 wxPyEndAllowThreads(__tstate);
36192 if (PyErr_Occurred()) SWIG_fail;
36193 }
36194 {
36195 #if wxUSE_UNICODE
36196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36197 #else
36198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36199 #endif
36200 }
36201 return resultobj;
36202 fail:
36203 return NULL;
36204 }
36205
36206
36207 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36208 PyObject *resultobj;
36209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36210 wxString *result;
36211 PyObject * obj0 = 0 ;
36212 char *kwnames[] = {
36213 (char *) "self", NULL
36214 };
36215
36216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36218 if (SWIG_arg_fail(1)) SWIG_fail;
36219 {
36220 PyThreadState* __tstate = wxPyBeginAllowThreads();
36221 {
36222 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36223 result = (wxString *) &_result_ref;
36224 }
36225
36226 wxPyEndAllowThreads(__tstate);
36227 if (PyErr_Occurred()) SWIG_fail;
36228 }
36229 {
36230 #if wxUSE_UNICODE
36231 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36232 #else
36233 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36234 #endif
36235 }
36236 return resultobj;
36237 fail:
36238 return NULL;
36239 }
36240
36241
36242 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36243 PyObject *resultobj;
36244 wxString *arg1 = 0 ;
36245 wxString result;
36246 bool temp1 = false ;
36247 PyObject * obj0 = 0 ;
36248 char *kwnames[] = {
36249 (char *) "text", NULL
36250 };
36251
36252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36253 {
36254 arg1 = wxString_in_helper(obj0);
36255 if (arg1 == NULL) SWIG_fail;
36256 temp1 = true;
36257 }
36258 {
36259 PyThreadState* __tstate = wxPyBeginAllowThreads();
36260 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36261
36262 wxPyEndAllowThreads(__tstate);
36263 if (PyErr_Occurred()) SWIG_fail;
36264 }
36265 {
36266 #if wxUSE_UNICODE
36267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36268 #else
36269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36270 #endif
36271 }
36272 {
36273 if (temp1)
36274 delete arg1;
36275 }
36276 return resultobj;
36277 fail:
36278 {
36279 if (temp1)
36280 delete arg1;
36281 }
36282 return NULL;
36283 }
36284
36285
36286 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36287 PyObject *resultobj;
36288 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36289 wxItemKind result;
36290 PyObject * obj0 = 0 ;
36291 char *kwnames[] = {
36292 (char *) "self", NULL
36293 };
36294
36295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36297 if (SWIG_arg_fail(1)) SWIG_fail;
36298 {
36299 PyThreadState* __tstate = wxPyBeginAllowThreads();
36300 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36301
36302 wxPyEndAllowThreads(__tstate);
36303 if (PyErr_Occurred()) SWIG_fail;
36304 }
36305 resultobj = SWIG_From_int((result));
36306 return resultobj;
36307 fail:
36308 return NULL;
36309 }
36310
36311
36312 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36313 PyObject *resultobj;
36314 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36315 wxItemKind arg2 ;
36316 PyObject * obj0 = 0 ;
36317 PyObject * obj1 = 0 ;
36318 char *kwnames[] = {
36319 (char *) "self",(char *) "kind", NULL
36320 };
36321
36322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36324 if (SWIG_arg_fail(1)) SWIG_fail;
36325 {
36326 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36327 if (SWIG_arg_fail(2)) SWIG_fail;
36328 }
36329 {
36330 PyThreadState* __tstate = wxPyBeginAllowThreads();
36331 (arg1)->SetKind((wxItemKind )arg2);
36332
36333 wxPyEndAllowThreads(__tstate);
36334 if (PyErr_Occurred()) SWIG_fail;
36335 }
36336 Py_INCREF(Py_None); resultobj = Py_None;
36337 return resultobj;
36338 fail:
36339 return NULL;
36340 }
36341
36342
36343 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36344 PyObject *resultobj;
36345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36346 bool arg2 ;
36347 PyObject * obj0 = 0 ;
36348 PyObject * obj1 = 0 ;
36349 char *kwnames[] = {
36350 (char *) "self",(char *) "checkable", NULL
36351 };
36352
36353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36355 if (SWIG_arg_fail(1)) SWIG_fail;
36356 {
36357 arg2 = (bool)(SWIG_As_bool(obj1));
36358 if (SWIG_arg_fail(2)) SWIG_fail;
36359 }
36360 {
36361 PyThreadState* __tstate = wxPyBeginAllowThreads();
36362 (arg1)->SetCheckable(arg2);
36363
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 Py_INCREF(Py_None); resultobj = Py_None;
36368 return resultobj;
36369 fail:
36370 return NULL;
36371 }
36372
36373
36374 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36375 PyObject *resultobj;
36376 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36377 bool result;
36378 PyObject * obj0 = 0 ;
36379 char *kwnames[] = {
36380 (char *) "self", NULL
36381 };
36382
36383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36385 if (SWIG_arg_fail(1)) SWIG_fail;
36386 {
36387 PyThreadState* __tstate = wxPyBeginAllowThreads();
36388 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36389
36390 wxPyEndAllowThreads(__tstate);
36391 if (PyErr_Occurred()) SWIG_fail;
36392 }
36393 {
36394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36395 }
36396 return resultobj;
36397 fail:
36398 return NULL;
36399 }
36400
36401
36402 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36403 PyObject *resultobj;
36404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36405 bool result;
36406 PyObject * obj0 = 0 ;
36407 char *kwnames[] = {
36408 (char *) "self", NULL
36409 };
36410
36411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36413 if (SWIG_arg_fail(1)) SWIG_fail;
36414 {
36415 PyThreadState* __tstate = wxPyBeginAllowThreads();
36416 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36417
36418 wxPyEndAllowThreads(__tstate);
36419 if (PyErr_Occurred()) SWIG_fail;
36420 }
36421 {
36422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36423 }
36424 return resultobj;
36425 fail:
36426 return NULL;
36427 }
36428
36429
36430 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36431 PyObject *resultobj;
36432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36433 wxMenu *arg2 = (wxMenu *) 0 ;
36434 PyObject * obj0 = 0 ;
36435 PyObject * obj1 = 0 ;
36436 char *kwnames[] = {
36437 (char *) "self",(char *) "menu", NULL
36438 };
36439
36440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36442 if (SWIG_arg_fail(1)) SWIG_fail;
36443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36444 if (SWIG_arg_fail(2)) SWIG_fail;
36445 {
36446 PyThreadState* __tstate = wxPyBeginAllowThreads();
36447 (arg1)->SetSubMenu(arg2);
36448
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 Py_INCREF(Py_None); resultobj = Py_None;
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj;
36461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36462 wxMenu *result;
36463 PyObject * obj0 = 0 ;
36464 char *kwnames[] = {
36465 (char *) "self", NULL
36466 };
36467
36468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36470 if (SWIG_arg_fail(1)) SWIG_fail;
36471 {
36472 PyThreadState* __tstate = wxPyBeginAllowThreads();
36473 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36474
36475 wxPyEndAllowThreads(__tstate);
36476 if (PyErr_Occurred()) SWIG_fail;
36477 }
36478 {
36479 resultobj = wxPyMake_wxObject(result, 0);
36480 }
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj;
36489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36490 bool arg2 = (bool) true ;
36491 PyObject * obj0 = 0 ;
36492 PyObject * obj1 = 0 ;
36493 char *kwnames[] = {
36494 (char *) "self",(char *) "enable", NULL
36495 };
36496
36497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36499 if (SWIG_arg_fail(1)) SWIG_fail;
36500 if (obj1) {
36501 {
36502 arg2 = (bool)(SWIG_As_bool(obj1));
36503 if (SWIG_arg_fail(2)) SWIG_fail;
36504 }
36505 }
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 (arg1)->Enable(arg2);
36509
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 Py_INCREF(Py_None); resultobj = Py_None;
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj;
36522 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36523 bool result;
36524 PyObject * obj0 = 0 ;
36525 char *kwnames[] = {
36526 (char *) "self", NULL
36527 };
36528
36529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36531 if (SWIG_arg_fail(1)) SWIG_fail;
36532 {
36533 PyThreadState* __tstate = wxPyBeginAllowThreads();
36534 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36535
36536 wxPyEndAllowThreads(__tstate);
36537 if (PyErr_Occurred()) SWIG_fail;
36538 }
36539 {
36540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36541 }
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj;
36550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36551 bool arg2 = (bool) true ;
36552 PyObject * obj0 = 0 ;
36553 PyObject * obj1 = 0 ;
36554 char *kwnames[] = {
36555 (char *) "self",(char *) "check", NULL
36556 };
36557
36558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36560 if (SWIG_arg_fail(1)) SWIG_fail;
36561 if (obj1) {
36562 {
36563 arg2 = (bool)(SWIG_As_bool(obj1));
36564 if (SWIG_arg_fail(2)) SWIG_fail;
36565 }
36566 }
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 (arg1)->Check(arg2);
36570
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 Py_INCREF(Py_None); resultobj = Py_None;
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj;
36583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36584 bool result;
36585 PyObject * obj0 = 0 ;
36586 char *kwnames[] = {
36587 (char *) "self", NULL
36588 };
36589
36590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36592 if (SWIG_arg_fail(1)) SWIG_fail;
36593 {
36594 PyThreadState* __tstate = wxPyBeginAllowThreads();
36595 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36596
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 {
36601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36602 }
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36610 PyObject *resultobj;
36611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36612 PyObject * obj0 = 0 ;
36613 char *kwnames[] = {
36614 (char *) "self", NULL
36615 };
36616
36617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36619 if (SWIG_arg_fail(1)) SWIG_fail;
36620 {
36621 PyThreadState* __tstate = wxPyBeginAllowThreads();
36622 (arg1)->Toggle();
36623
36624 wxPyEndAllowThreads(__tstate);
36625 if (PyErr_Occurred()) SWIG_fail;
36626 }
36627 Py_INCREF(Py_None); resultobj = Py_None;
36628 return resultobj;
36629 fail:
36630 return NULL;
36631 }
36632
36633
36634 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36635 PyObject *resultobj;
36636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36637 wxString *arg2 = 0 ;
36638 bool temp2 = false ;
36639 PyObject * obj0 = 0 ;
36640 PyObject * obj1 = 0 ;
36641 char *kwnames[] = {
36642 (char *) "self",(char *) "str", NULL
36643 };
36644
36645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36647 if (SWIG_arg_fail(1)) SWIG_fail;
36648 {
36649 arg2 = wxString_in_helper(obj1);
36650 if (arg2 == NULL) SWIG_fail;
36651 temp2 = true;
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 (arg1)->SetHelp((wxString const &)*arg2);
36656
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 Py_INCREF(Py_None); resultobj = Py_None;
36661 {
36662 if (temp2)
36663 delete arg2;
36664 }
36665 return resultobj;
36666 fail:
36667 {
36668 if (temp2)
36669 delete arg2;
36670 }
36671 return NULL;
36672 }
36673
36674
36675 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36676 PyObject *resultobj;
36677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36678 wxString *result;
36679 PyObject * obj0 = 0 ;
36680 char *kwnames[] = {
36681 (char *) "self", NULL
36682 };
36683
36684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36686 if (SWIG_arg_fail(1)) SWIG_fail;
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 {
36690 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36691 result = (wxString *) &_result_ref;
36692 }
36693
36694 wxPyEndAllowThreads(__tstate);
36695 if (PyErr_Occurred()) SWIG_fail;
36696 }
36697 {
36698 #if wxUSE_UNICODE
36699 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36700 #else
36701 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36702 #endif
36703 }
36704 return resultobj;
36705 fail:
36706 return NULL;
36707 }
36708
36709
36710 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36711 PyObject *resultobj;
36712 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36713 wxAcceleratorEntry *result;
36714 PyObject * obj0 = 0 ;
36715 char *kwnames[] = {
36716 (char *) "self", NULL
36717 };
36718
36719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36721 if (SWIG_arg_fail(1)) SWIG_fail;
36722 {
36723 PyThreadState* __tstate = wxPyBeginAllowThreads();
36724 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36725
36726 wxPyEndAllowThreads(__tstate);
36727 if (PyErr_Occurred()) SWIG_fail;
36728 }
36729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36730 return resultobj;
36731 fail:
36732 return NULL;
36733 }
36734
36735
36736 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36737 PyObject *resultobj;
36738 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36739 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36740 PyObject * obj0 = 0 ;
36741 PyObject * obj1 = 0 ;
36742 char *kwnames[] = {
36743 (char *) "self",(char *) "accel", NULL
36744 };
36745
36746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36748 if (SWIG_arg_fail(1)) SWIG_fail;
36749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36750 if (SWIG_arg_fail(2)) SWIG_fail;
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 (arg1)->SetAccel(arg2);
36754
36755 wxPyEndAllowThreads(__tstate);
36756 if (PyErr_Occurred()) SWIG_fail;
36757 }
36758 Py_INCREF(Py_None); resultobj = Py_None;
36759 return resultobj;
36760 fail:
36761 return NULL;
36762 }
36763
36764
36765 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36766 PyObject *resultobj;
36767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36768 wxFont *arg2 = 0 ;
36769 PyObject * obj0 = 0 ;
36770 PyObject * obj1 = 0 ;
36771 char *kwnames[] = {
36772 (char *) "self",(char *) "font", NULL
36773 };
36774
36775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36777 if (SWIG_arg_fail(1)) SWIG_fail;
36778 {
36779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36780 if (SWIG_arg_fail(2)) SWIG_fail;
36781 if (arg2 == NULL) {
36782 SWIG_null_ref("wxFont");
36783 }
36784 if (SWIG_arg_fail(2)) SWIG_fail;
36785 }
36786 {
36787 PyThreadState* __tstate = wxPyBeginAllowThreads();
36788 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36789
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 Py_INCREF(Py_None); resultobj = Py_None;
36794 return resultobj;
36795 fail:
36796 return NULL;
36797 }
36798
36799
36800 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36801 PyObject *resultobj;
36802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36803 wxFont result;
36804 PyObject * obj0 = 0 ;
36805 char *kwnames[] = {
36806 (char *) "self", NULL
36807 };
36808
36809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36811 if (SWIG_arg_fail(1)) SWIG_fail;
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 result = wxMenuItem_GetFont(arg1);
36815
36816 wxPyEndAllowThreads(__tstate);
36817 if (PyErr_Occurred()) SWIG_fail;
36818 }
36819 {
36820 wxFont * resultptr;
36821 resultptr = new wxFont((wxFont &)(result));
36822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36823 }
36824 return resultobj;
36825 fail:
36826 return NULL;
36827 }
36828
36829
36830 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36831 PyObject *resultobj;
36832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36833 wxColour *arg2 = 0 ;
36834 wxColour temp2 ;
36835 PyObject * obj0 = 0 ;
36836 PyObject * obj1 = 0 ;
36837 char *kwnames[] = {
36838 (char *) "self",(char *) "colText", NULL
36839 };
36840
36841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36843 if (SWIG_arg_fail(1)) SWIG_fail;
36844 {
36845 arg2 = &temp2;
36846 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36847 }
36848 {
36849 PyThreadState* __tstate = wxPyBeginAllowThreads();
36850 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36851
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 Py_INCREF(Py_None); resultobj = Py_None;
36856 return resultobj;
36857 fail:
36858 return NULL;
36859 }
36860
36861
36862 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36863 PyObject *resultobj;
36864 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36865 wxColour result;
36866 PyObject * obj0 = 0 ;
36867 char *kwnames[] = {
36868 (char *) "self", NULL
36869 };
36870
36871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36873 if (SWIG_arg_fail(1)) SWIG_fail;
36874 {
36875 PyThreadState* __tstate = wxPyBeginAllowThreads();
36876 result = wxMenuItem_GetTextColour(arg1);
36877
36878 wxPyEndAllowThreads(__tstate);
36879 if (PyErr_Occurred()) SWIG_fail;
36880 }
36881 {
36882 wxColour * resultptr;
36883 resultptr = new wxColour((wxColour &)(result));
36884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36885 }
36886 return resultobj;
36887 fail:
36888 return NULL;
36889 }
36890
36891
36892 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36893 PyObject *resultobj;
36894 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36895 wxColour *arg2 = 0 ;
36896 wxColour temp2 ;
36897 PyObject * obj0 = 0 ;
36898 PyObject * obj1 = 0 ;
36899 char *kwnames[] = {
36900 (char *) "self",(char *) "colBack", NULL
36901 };
36902
36903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36905 if (SWIG_arg_fail(1)) SWIG_fail;
36906 {
36907 arg2 = &temp2;
36908 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36909 }
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36913
36914 wxPyEndAllowThreads(__tstate);
36915 if (PyErr_Occurred()) SWIG_fail;
36916 }
36917 Py_INCREF(Py_None); resultobj = Py_None;
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36925 PyObject *resultobj;
36926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36927 wxColour result;
36928 PyObject * obj0 = 0 ;
36929 char *kwnames[] = {
36930 (char *) "self", NULL
36931 };
36932
36933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36935 if (SWIG_arg_fail(1)) SWIG_fail;
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 result = wxMenuItem_GetBackgroundColour(arg1);
36939
36940 wxPyEndAllowThreads(__tstate);
36941 if (PyErr_Occurred()) SWIG_fail;
36942 }
36943 {
36944 wxColour * resultptr;
36945 resultptr = new wxColour((wxColour &)(result));
36946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36947 }
36948 return resultobj;
36949 fail:
36950 return NULL;
36951 }
36952
36953
36954 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36955 PyObject *resultobj;
36956 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36957 wxBitmap *arg2 = 0 ;
36958 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36959 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36960 PyObject * obj0 = 0 ;
36961 PyObject * obj1 = 0 ;
36962 PyObject * obj2 = 0 ;
36963 char *kwnames[] = {
36964 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36965 };
36966
36967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36969 if (SWIG_arg_fail(1)) SWIG_fail;
36970 {
36971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36972 if (SWIG_arg_fail(2)) SWIG_fail;
36973 if (arg2 == NULL) {
36974 SWIG_null_ref("wxBitmap");
36975 }
36976 if (SWIG_arg_fail(2)) SWIG_fail;
36977 }
36978 if (obj2) {
36979 {
36980 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36981 if (SWIG_arg_fail(3)) SWIG_fail;
36982 if (arg3 == NULL) {
36983 SWIG_null_ref("wxBitmap");
36984 }
36985 if (SWIG_arg_fail(3)) SWIG_fail;
36986 }
36987 }
36988 {
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36991
36992 wxPyEndAllowThreads(__tstate);
36993 if (PyErr_Occurred()) SWIG_fail;
36994 }
36995 Py_INCREF(Py_None); resultobj = Py_None;
36996 return resultobj;
36997 fail:
36998 return NULL;
36999 }
37000
37001
37002 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37003 PyObject *resultobj;
37004 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37005 wxBitmap *arg2 = 0 ;
37006 PyObject * obj0 = 0 ;
37007 PyObject * obj1 = 0 ;
37008 char *kwnames[] = {
37009 (char *) "self",(char *) "bmpDisabled", NULL
37010 };
37011
37012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37014 if (SWIG_arg_fail(1)) SWIG_fail;
37015 {
37016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37017 if (SWIG_arg_fail(2)) SWIG_fail;
37018 if (arg2 == NULL) {
37019 SWIG_null_ref("wxBitmap");
37020 }
37021 if (SWIG_arg_fail(2)) SWIG_fail;
37022 }
37023 {
37024 PyThreadState* __tstate = wxPyBeginAllowThreads();
37025 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37026
37027 wxPyEndAllowThreads(__tstate);
37028 if (PyErr_Occurred()) SWIG_fail;
37029 }
37030 Py_INCREF(Py_None); resultobj = Py_None;
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37038 PyObject *resultobj;
37039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37040 wxBitmap *result;
37041 PyObject * obj0 = 0 ;
37042 char *kwnames[] = {
37043 (char *) "self", NULL
37044 };
37045
37046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37048 if (SWIG_arg_fail(1)) SWIG_fail;
37049 {
37050 PyThreadState* __tstate = wxPyBeginAllowThreads();
37051 {
37052 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37053 result = (wxBitmap *) &_result_ref;
37054 }
37055
37056 wxPyEndAllowThreads(__tstate);
37057 if (PyErr_Occurred()) SWIG_fail;
37058 }
37059 {
37060 wxBitmap* resultptr = new wxBitmap(*result);
37061 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37062 }
37063 return resultobj;
37064 fail:
37065 return NULL;
37066 }
37067
37068
37069 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37070 PyObject *resultobj;
37071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37072 int arg2 ;
37073 PyObject * obj0 = 0 ;
37074 PyObject * obj1 = 0 ;
37075 char *kwnames[] = {
37076 (char *) "self",(char *) "nWidth", NULL
37077 };
37078
37079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37081 if (SWIG_arg_fail(1)) SWIG_fail;
37082 {
37083 arg2 = (int)(SWIG_As_int(obj1));
37084 if (SWIG_arg_fail(2)) SWIG_fail;
37085 }
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 wxMenuItem_SetMarginWidth(arg1,arg2);
37089
37090 wxPyEndAllowThreads(__tstate);
37091 if (PyErr_Occurred()) SWIG_fail;
37092 }
37093 Py_INCREF(Py_None); resultobj = Py_None;
37094 return resultobj;
37095 fail:
37096 return NULL;
37097 }
37098
37099
37100 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37101 PyObject *resultobj;
37102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37103 int result;
37104 PyObject * obj0 = 0 ;
37105 char *kwnames[] = {
37106 (char *) "self", NULL
37107 };
37108
37109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37111 if (SWIG_arg_fail(1)) SWIG_fail;
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 result = (int)wxMenuItem_GetMarginWidth(arg1);
37115
37116 wxPyEndAllowThreads(__tstate);
37117 if (PyErr_Occurred()) SWIG_fail;
37118 }
37119 {
37120 resultobj = SWIG_From_int((int)(result));
37121 }
37122 return resultobj;
37123 fail:
37124 return NULL;
37125 }
37126
37127
37128 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37129 PyObject *resultobj;
37130 int result;
37131 char *kwnames[] = {
37132 NULL
37133 };
37134
37135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 result = (int)MenuItem_GetDefaultMarginWidth();
37139
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 {
37144 resultobj = SWIG_From_int((int)(result));
37145 }
37146 return resultobj;
37147 fail:
37148 return NULL;
37149 }
37150
37151
37152 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37153 PyObject *resultobj;
37154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37155 bool result;
37156 PyObject * obj0 = 0 ;
37157 char *kwnames[] = {
37158 (char *) "self", NULL
37159 };
37160
37161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37163 if (SWIG_arg_fail(1)) SWIG_fail;
37164 {
37165 PyThreadState* __tstate = wxPyBeginAllowThreads();
37166 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37167
37168 wxPyEndAllowThreads(__tstate);
37169 if (PyErr_Occurred()) SWIG_fail;
37170 }
37171 {
37172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37173 }
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj;
37182 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37183 bool arg2 = (bool) true ;
37184 PyObject * obj0 = 0 ;
37185 PyObject * obj1 = 0 ;
37186 char *kwnames[] = {
37187 (char *) "self",(char *) "ownerDrawn", NULL
37188 };
37189
37190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37192 if (SWIG_arg_fail(1)) SWIG_fail;
37193 if (obj1) {
37194 {
37195 arg2 = (bool)(SWIG_As_bool(obj1));
37196 if (SWIG_arg_fail(2)) SWIG_fail;
37197 }
37198 }
37199 {
37200 PyThreadState* __tstate = wxPyBeginAllowThreads();
37201 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37202
37203 wxPyEndAllowThreads(__tstate);
37204 if (PyErr_Occurred()) SWIG_fail;
37205 }
37206 Py_INCREF(Py_None); resultobj = Py_None;
37207 return resultobj;
37208 fail:
37209 return NULL;
37210 }
37211
37212
37213 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj;
37215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37216 PyObject * obj0 = 0 ;
37217 char *kwnames[] = {
37218 (char *) "self", NULL
37219 };
37220
37221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37223 if (SWIG_arg_fail(1)) SWIG_fail;
37224 {
37225 PyThreadState* __tstate = wxPyBeginAllowThreads();
37226 wxMenuItem_ResetOwnerDrawn(arg1);
37227
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 Py_INCREF(Py_None); resultobj = Py_None;
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj;
37240 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37241 wxBitmap *arg2 = 0 ;
37242 PyObject * obj0 = 0 ;
37243 PyObject * obj1 = 0 ;
37244 char *kwnames[] = {
37245 (char *) "self",(char *) "bitmap", NULL
37246 };
37247
37248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37250 if (SWIG_arg_fail(1)) SWIG_fail;
37251 {
37252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37253 if (SWIG_arg_fail(2)) SWIG_fail;
37254 if (arg2 == NULL) {
37255 SWIG_null_ref("wxBitmap");
37256 }
37257 if (SWIG_arg_fail(2)) SWIG_fail;
37258 }
37259 {
37260 PyThreadState* __tstate = wxPyBeginAllowThreads();
37261 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37262
37263 wxPyEndAllowThreads(__tstate);
37264 if (PyErr_Occurred()) SWIG_fail;
37265 }
37266 Py_INCREF(Py_None); resultobj = Py_None;
37267 return resultobj;
37268 fail:
37269 return NULL;
37270 }
37271
37272
37273 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37274 PyObject *resultobj;
37275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37276 wxBitmap *result;
37277 PyObject * obj0 = 0 ;
37278 char *kwnames[] = {
37279 (char *) "self", NULL
37280 };
37281
37282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37284 if (SWIG_arg_fail(1)) SWIG_fail;
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 {
37288 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37289 result = (wxBitmap *) &_result_ref;
37290 }
37291
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 {
37296 wxBitmap* resultptr = new wxBitmap(*result);
37297 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37298 }
37299 return resultobj;
37300 fail:
37301 return NULL;
37302 }
37303
37304
37305 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37306 PyObject *obj;
37307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37308 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37309 Py_INCREF(obj);
37310 return Py_BuildValue((char *)"");
37311 }
37312 static int _wrap_ControlNameStr_set(PyObject *) {
37313 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37314 return 1;
37315 }
37316
37317
37318 static PyObject *_wrap_ControlNameStr_get(void) {
37319 PyObject *pyobj;
37320
37321 {
37322 #if wxUSE_UNICODE
37323 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37324 #else
37325 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37326 #endif
37327 }
37328 return pyobj;
37329 }
37330
37331
37332 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37333 PyObject *resultobj;
37334 wxWindow *arg1 = (wxWindow *) 0 ;
37335 int arg2 = (int) -1 ;
37336 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37337 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37338 wxSize const &arg4_defvalue = wxDefaultSize ;
37339 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37340 long arg5 = (long) 0 ;
37341 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37342 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37343 wxString const &arg7_defvalue = wxPyControlNameStr ;
37344 wxString *arg7 = (wxString *) &arg7_defvalue ;
37345 wxControl *result;
37346 wxPoint temp3 ;
37347 wxSize temp4 ;
37348 bool temp7 = false ;
37349 PyObject * obj0 = 0 ;
37350 PyObject * obj1 = 0 ;
37351 PyObject * obj2 = 0 ;
37352 PyObject * obj3 = 0 ;
37353 PyObject * obj4 = 0 ;
37354 PyObject * obj5 = 0 ;
37355 PyObject * obj6 = 0 ;
37356 char *kwnames[] = {
37357 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37358 };
37359
37360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37362 if (SWIG_arg_fail(1)) SWIG_fail;
37363 if (obj1) {
37364 {
37365 arg2 = (int)(SWIG_As_int(obj1));
37366 if (SWIG_arg_fail(2)) SWIG_fail;
37367 }
37368 }
37369 if (obj2) {
37370 {
37371 arg3 = &temp3;
37372 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37373 }
37374 }
37375 if (obj3) {
37376 {
37377 arg4 = &temp4;
37378 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37379 }
37380 }
37381 if (obj4) {
37382 {
37383 arg5 = (long)(SWIG_As_long(obj4));
37384 if (SWIG_arg_fail(5)) SWIG_fail;
37385 }
37386 }
37387 if (obj5) {
37388 {
37389 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37390 if (SWIG_arg_fail(6)) SWIG_fail;
37391 if (arg6 == NULL) {
37392 SWIG_null_ref("wxValidator");
37393 }
37394 if (SWIG_arg_fail(6)) SWIG_fail;
37395 }
37396 }
37397 if (obj6) {
37398 {
37399 arg7 = wxString_in_helper(obj6);
37400 if (arg7 == NULL) SWIG_fail;
37401 temp7 = true;
37402 }
37403 }
37404 {
37405 if (!wxPyCheckForApp()) SWIG_fail;
37406 PyThreadState* __tstate = wxPyBeginAllowThreads();
37407 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37408
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37413 {
37414 if (temp7)
37415 delete arg7;
37416 }
37417 return resultobj;
37418 fail:
37419 {
37420 if (temp7)
37421 delete arg7;
37422 }
37423 return NULL;
37424 }
37425
37426
37427 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37428 PyObject *resultobj;
37429 wxControl *result;
37430 char *kwnames[] = {
37431 NULL
37432 };
37433
37434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37435 {
37436 if (!wxPyCheckForApp()) SWIG_fail;
37437 PyThreadState* __tstate = wxPyBeginAllowThreads();
37438 result = (wxControl *)new wxControl();
37439
37440 wxPyEndAllowThreads(__tstate);
37441 if (PyErr_Occurred()) SWIG_fail;
37442 }
37443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37444 return resultobj;
37445 fail:
37446 return NULL;
37447 }
37448
37449
37450 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37451 PyObject *resultobj;
37452 wxControl *arg1 = (wxControl *) 0 ;
37453 wxWindow *arg2 = (wxWindow *) 0 ;
37454 int arg3 = (int) -1 ;
37455 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37456 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37457 wxSize const &arg5_defvalue = wxDefaultSize ;
37458 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37459 long arg6 = (long) 0 ;
37460 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37461 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37462 wxString const &arg8_defvalue = wxPyControlNameStr ;
37463 wxString *arg8 = (wxString *) &arg8_defvalue ;
37464 bool result;
37465 wxPoint temp4 ;
37466 wxSize temp5 ;
37467 bool temp8 = false ;
37468 PyObject * obj0 = 0 ;
37469 PyObject * obj1 = 0 ;
37470 PyObject * obj2 = 0 ;
37471 PyObject * obj3 = 0 ;
37472 PyObject * obj4 = 0 ;
37473 PyObject * obj5 = 0 ;
37474 PyObject * obj6 = 0 ;
37475 PyObject * obj7 = 0 ;
37476 char *kwnames[] = {
37477 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37478 };
37479
37480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37482 if (SWIG_arg_fail(1)) SWIG_fail;
37483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37484 if (SWIG_arg_fail(2)) SWIG_fail;
37485 if (obj2) {
37486 {
37487 arg3 = (int)(SWIG_As_int(obj2));
37488 if (SWIG_arg_fail(3)) SWIG_fail;
37489 }
37490 }
37491 if (obj3) {
37492 {
37493 arg4 = &temp4;
37494 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37495 }
37496 }
37497 if (obj4) {
37498 {
37499 arg5 = &temp5;
37500 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37501 }
37502 }
37503 if (obj5) {
37504 {
37505 arg6 = (long)(SWIG_As_long(obj5));
37506 if (SWIG_arg_fail(6)) SWIG_fail;
37507 }
37508 }
37509 if (obj6) {
37510 {
37511 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37512 if (SWIG_arg_fail(7)) SWIG_fail;
37513 if (arg7 == NULL) {
37514 SWIG_null_ref("wxValidator");
37515 }
37516 if (SWIG_arg_fail(7)) SWIG_fail;
37517 }
37518 }
37519 if (obj7) {
37520 {
37521 arg8 = wxString_in_helper(obj7);
37522 if (arg8 == NULL) SWIG_fail;
37523 temp8 = true;
37524 }
37525 }
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37529
37530 wxPyEndAllowThreads(__tstate);
37531 if (PyErr_Occurred()) SWIG_fail;
37532 }
37533 {
37534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37535 }
37536 {
37537 if (temp8)
37538 delete arg8;
37539 }
37540 return resultobj;
37541 fail:
37542 {
37543 if (temp8)
37544 delete arg8;
37545 }
37546 return NULL;
37547 }
37548
37549
37550 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37551 PyObject *resultobj;
37552 wxControl *arg1 = (wxControl *) 0 ;
37553 wxCommandEvent *arg2 = 0 ;
37554 PyObject * obj0 = 0 ;
37555 PyObject * obj1 = 0 ;
37556 char *kwnames[] = {
37557 (char *) "self",(char *) "event", NULL
37558 };
37559
37560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37562 if (SWIG_arg_fail(1)) SWIG_fail;
37563 {
37564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37565 if (SWIG_arg_fail(2)) SWIG_fail;
37566 if (arg2 == NULL) {
37567 SWIG_null_ref("wxCommandEvent");
37568 }
37569 if (SWIG_arg_fail(2)) SWIG_fail;
37570 }
37571 {
37572 PyThreadState* __tstate = wxPyBeginAllowThreads();
37573 (arg1)->Command(*arg2);
37574
37575 wxPyEndAllowThreads(__tstate);
37576 if (PyErr_Occurred()) SWIG_fail;
37577 }
37578 Py_INCREF(Py_None); resultobj = Py_None;
37579 return resultobj;
37580 fail:
37581 return NULL;
37582 }
37583
37584
37585 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37586 PyObject *resultobj;
37587 wxControl *arg1 = (wxControl *) 0 ;
37588 wxString result;
37589 PyObject * obj0 = 0 ;
37590 char *kwnames[] = {
37591 (char *) "self", NULL
37592 };
37593
37594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37596 if (SWIG_arg_fail(1)) SWIG_fail;
37597 {
37598 PyThreadState* __tstate = wxPyBeginAllowThreads();
37599 result = (arg1)->GetLabel();
37600
37601 wxPyEndAllowThreads(__tstate);
37602 if (PyErr_Occurred()) SWIG_fail;
37603 }
37604 {
37605 #if wxUSE_UNICODE
37606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37607 #else
37608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37609 #endif
37610 }
37611 return resultobj;
37612 fail:
37613 return NULL;
37614 }
37615
37616
37617 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37618 PyObject *resultobj;
37619 wxControl *arg1 = (wxControl *) 0 ;
37620 wxString *arg2 = 0 ;
37621 bool temp2 = false ;
37622 PyObject * obj0 = 0 ;
37623 PyObject * obj1 = 0 ;
37624 char *kwnames[] = {
37625 (char *) "self",(char *) "label", NULL
37626 };
37627
37628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37630 if (SWIG_arg_fail(1)) SWIG_fail;
37631 {
37632 arg2 = wxString_in_helper(obj1);
37633 if (arg2 == NULL) SWIG_fail;
37634 temp2 = true;
37635 }
37636 {
37637 PyThreadState* __tstate = wxPyBeginAllowThreads();
37638 (arg1)->SetLabel((wxString const &)*arg2);
37639
37640 wxPyEndAllowThreads(__tstate);
37641 if (PyErr_Occurred()) SWIG_fail;
37642 }
37643 Py_INCREF(Py_None); resultobj = Py_None;
37644 {
37645 if (temp2)
37646 delete arg2;
37647 }
37648 return resultobj;
37649 fail:
37650 {
37651 if (temp2)
37652 delete arg2;
37653 }
37654 return NULL;
37655 }
37656
37657
37658 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37659 PyObject *resultobj;
37660 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37661 wxVisualAttributes result;
37662 PyObject * obj0 = 0 ;
37663 char *kwnames[] = {
37664 (char *) "variant", NULL
37665 };
37666
37667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37668 if (obj0) {
37669 {
37670 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37671 if (SWIG_arg_fail(1)) SWIG_fail;
37672 }
37673 }
37674 {
37675 if (!wxPyCheckForApp()) SWIG_fail;
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37678
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 {
37683 wxVisualAttributes * resultptr;
37684 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37685 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37686 }
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37694 PyObject *obj;
37695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37696 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37697 Py_INCREF(obj);
37698 return Py_BuildValue((char *)"");
37699 }
37700 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37701 PyObject *resultobj;
37702 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37703 wxString *arg2 = 0 ;
37704 PyObject *arg3 = (PyObject *) NULL ;
37705 int result;
37706 bool temp2 = false ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 PyObject * obj2 = 0 ;
37710 char *kwnames[] = {
37711 (char *) "self",(char *) "item",(char *) "clientData", NULL
37712 };
37713
37714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37716 if (SWIG_arg_fail(1)) SWIG_fail;
37717 {
37718 arg2 = wxString_in_helper(obj1);
37719 if (arg2 == NULL) SWIG_fail;
37720 temp2 = true;
37721 }
37722 if (obj2) {
37723 arg3 = obj2;
37724 }
37725 {
37726 PyThreadState* __tstate = wxPyBeginAllowThreads();
37727 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37728
37729 wxPyEndAllowThreads(__tstate);
37730 if (PyErr_Occurred()) SWIG_fail;
37731 }
37732 {
37733 resultobj = SWIG_From_int((int)(result));
37734 }
37735 {
37736 if (temp2)
37737 delete arg2;
37738 }
37739 return resultobj;
37740 fail:
37741 {
37742 if (temp2)
37743 delete arg2;
37744 }
37745 return NULL;
37746 }
37747
37748
37749 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37750 PyObject *resultobj;
37751 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37752 wxArrayString *arg2 = 0 ;
37753 bool temp2 = false ;
37754 PyObject * obj0 = 0 ;
37755 PyObject * obj1 = 0 ;
37756 char *kwnames[] = {
37757 (char *) "self",(char *) "strings", NULL
37758 };
37759
37760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37762 if (SWIG_arg_fail(1)) SWIG_fail;
37763 {
37764 if (! PySequence_Check(obj1)) {
37765 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37766 SWIG_fail;
37767 }
37768 arg2 = new wxArrayString;
37769 temp2 = true;
37770 int i, len=PySequence_Length(obj1);
37771 for (i=0; i<len; i++) {
37772 PyObject* item = PySequence_GetItem(obj1, i);
37773 #if wxUSE_UNICODE
37774 PyObject* str = PyObject_Unicode(item);
37775 #else
37776 PyObject* str = PyObject_Str(item);
37777 #endif
37778 if (PyErr_Occurred()) SWIG_fail;
37779 arg2->Add(Py2wxString(str));
37780 Py_DECREF(item);
37781 Py_DECREF(str);
37782 }
37783 }
37784 {
37785 PyThreadState* __tstate = wxPyBeginAllowThreads();
37786 (arg1)->Append((wxArrayString const &)*arg2);
37787
37788 wxPyEndAllowThreads(__tstate);
37789 if (PyErr_Occurred()) SWIG_fail;
37790 }
37791 Py_INCREF(Py_None); resultobj = Py_None;
37792 {
37793 if (temp2) delete arg2;
37794 }
37795 return resultobj;
37796 fail:
37797 {
37798 if (temp2) delete arg2;
37799 }
37800 return NULL;
37801 }
37802
37803
37804 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37805 PyObject *resultobj;
37806 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37807 wxString *arg2 = 0 ;
37808 int arg3 ;
37809 PyObject *arg4 = (PyObject *) NULL ;
37810 int result;
37811 bool temp2 = false ;
37812 PyObject * obj0 = 0 ;
37813 PyObject * obj1 = 0 ;
37814 PyObject * obj2 = 0 ;
37815 PyObject * obj3 = 0 ;
37816 char *kwnames[] = {
37817 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37818 };
37819
37820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37822 if (SWIG_arg_fail(1)) SWIG_fail;
37823 {
37824 arg2 = wxString_in_helper(obj1);
37825 if (arg2 == NULL) SWIG_fail;
37826 temp2 = true;
37827 }
37828 {
37829 arg3 = (int)(SWIG_As_int(obj2));
37830 if (SWIG_arg_fail(3)) SWIG_fail;
37831 }
37832 if (obj3) {
37833 arg4 = obj3;
37834 }
37835 {
37836 PyThreadState* __tstate = wxPyBeginAllowThreads();
37837 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37838
37839 wxPyEndAllowThreads(__tstate);
37840 if (PyErr_Occurred()) SWIG_fail;
37841 }
37842 {
37843 resultobj = SWIG_From_int((int)(result));
37844 }
37845 {
37846 if (temp2)
37847 delete arg2;
37848 }
37849 return resultobj;
37850 fail:
37851 {
37852 if (temp2)
37853 delete arg2;
37854 }
37855 return NULL;
37856 }
37857
37858
37859 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37860 PyObject *resultobj;
37861 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37862 PyObject * obj0 = 0 ;
37863 char *kwnames[] = {
37864 (char *) "self", NULL
37865 };
37866
37867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37869 if (SWIG_arg_fail(1)) SWIG_fail;
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 (arg1)->Clear();
37873
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 Py_INCREF(Py_None); resultobj = Py_None;
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37885 PyObject *resultobj;
37886 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37887 int arg2 ;
37888 PyObject * obj0 = 0 ;
37889 PyObject * obj1 = 0 ;
37890 char *kwnames[] = {
37891 (char *) "self",(char *) "n", NULL
37892 };
37893
37894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37896 if (SWIG_arg_fail(1)) SWIG_fail;
37897 {
37898 arg2 = (int)(SWIG_As_int(obj1));
37899 if (SWIG_arg_fail(2)) SWIG_fail;
37900 }
37901 {
37902 PyThreadState* __tstate = wxPyBeginAllowThreads();
37903 (arg1)->Delete(arg2);
37904
37905 wxPyEndAllowThreads(__tstate);
37906 if (PyErr_Occurred()) SWIG_fail;
37907 }
37908 Py_INCREF(Py_None); resultobj = Py_None;
37909 return resultobj;
37910 fail:
37911 return NULL;
37912 }
37913
37914
37915 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37916 PyObject *resultobj;
37917 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37918 int arg2 ;
37919 PyObject *result;
37920 PyObject * obj0 = 0 ;
37921 PyObject * obj1 = 0 ;
37922 char *kwnames[] = {
37923 (char *) "self",(char *) "n", NULL
37924 };
37925
37926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37928 if (SWIG_arg_fail(1)) SWIG_fail;
37929 {
37930 arg2 = (int)(SWIG_As_int(obj1));
37931 if (SWIG_arg_fail(2)) SWIG_fail;
37932 }
37933 {
37934 PyThreadState* __tstate = wxPyBeginAllowThreads();
37935 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37936
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 resultobj = result;
37941 return resultobj;
37942 fail:
37943 return NULL;
37944 }
37945
37946
37947 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37948 PyObject *resultobj;
37949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37950 int arg2 ;
37951 PyObject *arg3 = (PyObject *) 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 PyObject * obj2 = 0 ;
37955 char *kwnames[] = {
37956 (char *) "self",(char *) "n",(char *) "clientData", NULL
37957 };
37958
37959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37961 if (SWIG_arg_fail(1)) SWIG_fail;
37962 {
37963 arg2 = (int)(SWIG_As_int(obj1));
37964 if (SWIG_arg_fail(2)) SWIG_fail;
37965 }
37966 arg3 = obj2;
37967 {
37968 PyThreadState* __tstate = wxPyBeginAllowThreads();
37969 wxItemContainer_SetClientData(arg1,arg2,arg3);
37970
37971 wxPyEndAllowThreads(__tstate);
37972 if (PyErr_Occurred()) SWIG_fail;
37973 }
37974 Py_INCREF(Py_None); resultobj = Py_None;
37975 return resultobj;
37976 fail:
37977 return NULL;
37978 }
37979
37980
37981 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37982 PyObject *resultobj;
37983 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37984 int result;
37985 PyObject * obj0 = 0 ;
37986 char *kwnames[] = {
37987 (char *) "self", NULL
37988 };
37989
37990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37992 if (SWIG_arg_fail(1)) SWIG_fail;
37993 {
37994 PyThreadState* __tstate = wxPyBeginAllowThreads();
37995 result = (int)((wxItemContainer const *)arg1)->GetCount();
37996
37997 wxPyEndAllowThreads(__tstate);
37998 if (PyErr_Occurred()) SWIG_fail;
37999 }
38000 {
38001 resultobj = SWIG_From_int((int)(result));
38002 }
38003 return resultobj;
38004 fail:
38005 return NULL;
38006 }
38007
38008
38009 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38010 PyObject *resultobj;
38011 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38012 bool result;
38013 PyObject * obj0 = 0 ;
38014 char *kwnames[] = {
38015 (char *) "self", NULL
38016 };
38017
38018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38020 if (SWIG_arg_fail(1)) SWIG_fail;
38021 {
38022 PyThreadState* __tstate = wxPyBeginAllowThreads();
38023 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38024
38025 wxPyEndAllowThreads(__tstate);
38026 if (PyErr_Occurred()) SWIG_fail;
38027 }
38028 {
38029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38030 }
38031 return resultobj;
38032 fail:
38033 return NULL;
38034 }
38035
38036
38037 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38038 PyObject *resultobj;
38039 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38040 int arg2 ;
38041 wxString result;
38042 PyObject * obj0 = 0 ;
38043 PyObject * obj1 = 0 ;
38044 char *kwnames[] = {
38045 (char *) "self",(char *) "n", NULL
38046 };
38047
38048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38050 if (SWIG_arg_fail(1)) SWIG_fail;
38051 {
38052 arg2 = (int)(SWIG_As_int(obj1));
38053 if (SWIG_arg_fail(2)) SWIG_fail;
38054 }
38055 {
38056 PyThreadState* __tstate = wxPyBeginAllowThreads();
38057 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38058
38059 wxPyEndAllowThreads(__tstate);
38060 if (PyErr_Occurred()) SWIG_fail;
38061 }
38062 {
38063 #if wxUSE_UNICODE
38064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38065 #else
38066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38067 #endif
38068 }
38069 return resultobj;
38070 fail:
38071 return NULL;
38072 }
38073
38074
38075 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38076 PyObject *resultobj;
38077 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38078 wxArrayString result;
38079 PyObject * obj0 = 0 ;
38080 char *kwnames[] = {
38081 (char *) "self", NULL
38082 };
38083
38084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38086 if (SWIG_arg_fail(1)) SWIG_fail;
38087 {
38088 PyThreadState* __tstate = wxPyBeginAllowThreads();
38089 result = ((wxItemContainer const *)arg1)->GetStrings();
38090
38091 wxPyEndAllowThreads(__tstate);
38092 if (PyErr_Occurred()) SWIG_fail;
38093 }
38094 {
38095 resultobj = wxArrayString2PyList_helper(result);
38096 }
38097 return resultobj;
38098 fail:
38099 return NULL;
38100 }
38101
38102
38103 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38104 PyObject *resultobj;
38105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38106 int arg2 ;
38107 wxString *arg3 = 0 ;
38108 bool temp3 = false ;
38109 PyObject * obj0 = 0 ;
38110 PyObject * obj1 = 0 ;
38111 PyObject * obj2 = 0 ;
38112 char *kwnames[] = {
38113 (char *) "self",(char *) "n",(char *) "s", NULL
38114 };
38115
38116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38118 if (SWIG_arg_fail(1)) SWIG_fail;
38119 {
38120 arg2 = (int)(SWIG_As_int(obj1));
38121 if (SWIG_arg_fail(2)) SWIG_fail;
38122 }
38123 {
38124 arg3 = wxString_in_helper(obj2);
38125 if (arg3 == NULL) SWIG_fail;
38126 temp3 = true;
38127 }
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 (arg1)->SetString(arg2,(wxString const &)*arg3);
38131
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 Py_INCREF(Py_None); resultobj = Py_None;
38136 {
38137 if (temp3)
38138 delete arg3;
38139 }
38140 return resultobj;
38141 fail:
38142 {
38143 if (temp3)
38144 delete arg3;
38145 }
38146 return NULL;
38147 }
38148
38149
38150 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38151 PyObject *resultobj;
38152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38153 wxString *arg2 = 0 ;
38154 int result;
38155 bool temp2 = false ;
38156 PyObject * obj0 = 0 ;
38157 PyObject * obj1 = 0 ;
38158 char *kwnames[] = {
38159 (char *) "self",(char *) "s", NULL
38160 };
38161
38162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38164 if (SWIG_arg_fail(1)) SWIG_fail;
38165 {
38166 arg2 = wxString_in_helper(obj1);
38167 if (arg2 == NULL) SWIG_fail;
38168 temp2 = true;
38169 }
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38173
38174 wxPyEndAllowThreads(__tstate);
38175 if (PyErr_Occurred()) SWIG_fail;
38176 }
38177 {
38178 resultobj = SWIG_From_int((int)(result));
38179 }
38180 {
38181 if (temp2)
38182 delete arg2;
38183 }
38184 return resultobj;
38185 fail:
38186 {
38187 if (temp2)
38188 delete arg2;
38189 }
38190 return NULL;
38191 }
38192
38193
38194 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj;
38196 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38197 int arg2 ;
38198 PyObject * obj0 = 0 ;
38199 PyObject * obj1 = 0 ;
38200 char *kwnames[] = {
38201 (char *) "self",(char *) "n", NULL
38202 };
38203
38204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38206 if (SWIG_arg_fail(1)) SWIG_fail;
38207 {
38208 arg2 = (int)(SWIG_As_int(obj1));
38209 if (SWIG_arg_fail(2)) SWIG_fail;
38210 }
38211 {
38212 PyThreadState* __tstate = wxPyBeginAllowThreads();
38213 (arg1)->SetSelection(arg2);
38214
38215 wxPyEndAllowThreads(__tstate);
38216 if (PyErr_Occurred()) SWIG_fail;
38217 }
38218 Py_INCREF(Py_None); resultobj = Py_None;
38219 return resultobj;
38220 fail:
38221 return NULL;
38222 }
38223
38224
38225 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38226 PyObject *resultobj;
38227 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38228 int result;
38229 PyObject * obj0 = 0 ;
38230 char *kwnames[] = {
38231 (char *) "self", NULL
38232 };
38233
38234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38236 if (SWIG_arg_fail(1)) SWIG_fail;
38237 {
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38240
38241 wxPyEndAllowThreads(__tstate);
38242 if (PyErr_Occurred()) SWIG_fail;
38243 }
38244 {
38245 resultobj = SWIG_From_int((int)(result));
38246 }
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj;
38255 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38256 wxString *arg2 = 0 ;
38257 bool result;
38258 bool temp2 = false ;
38259 PyObject * obj0 = 0 ;
38260 PyObject * obj1 = 0 ;
38261 char *kwnames[] = {
38262 (char *) "self",(char *) "s", NULL
38263 };
38264
38265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38267 if (SWIG_arg_fail(1)) SWIG_fail;
38268 {
38269 arg2 = wxString_in_helper(obj1);
38270 if (arg2 == NULL) SWIG_fail;
38271 temp2 = true;
38272 }
38273 {
38274 PyThreadState* __tstate = wxPyBeginAllowThreads();
38275 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38276
38277 wxPyEndAllowThreads(__tstate);
38278 if (PyErr_Occurred()) SWIG_fail;
38279 }
38280 {
38281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38282 }
38283 {
38284 if (temp2)
38285 delete arg2;
38286 }
38287 return resultobj;
38288 fail:
38289 {
38290 if (temp2)
38291 delete arg2;
38292 }
38293 return NULL;
38294 }
38295
38296
38297 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38298 PyObject *resultobj;
38299 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38300 wxString result;
38301 PyObject * obj0 = 0 ;
38302 char *kwnames[] = {
38303 (char *) "self", NULL
38304 };
38305
38306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38308 if (SWIG_arg_fail(1)) SWIG_fail;
38309 {
38310 PyThreadState* __tstate = wxPyBeginAllowThreads();
38311 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38312
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 {
38317 #if wxUSE_UNICODE
38318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38319 #else
38320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38321 #endif
38322 }
38323 return resultobj;
38324 fail:
38325 return NULL;
38326 }
38327
38328
38329 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj;
38331 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38332 int arg2 ;
38333 PyObject * obj0 = 0 ;
38334 PyObject * obj1 = 0 ;
38335 char *kwnames[] = {
38336 (char *) "self",(char *) "n", NULL
38337 };
38338
38339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38341 if (SWIG_arg_fail(1)) SWIG_fail;
38342 {
38343 arg2 = (int)(SWIG_As_int(obj1));
38344 if (SWIG_arg_fail(2)) SWIG_fail;
38345 }
38346 {
38347 PyThreadState* __tstate = wxPyBeginAllowThreads();
38348 (arg1)->Select(arg2);
38349
38350 wxPyEndAllowThreads(__tstate);
38351 if (PyErr_Occurred()) SWIG_fail;
38352 }
38353 Py_INCREF(Py_None); resultobj = Py_None;
38354 return resultobj;
38355 fail:
38356 return NULL;
38357 }
38358
38359
38360 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38361 PyObject *obj;
38362 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38363 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38364 Py_INCREF(obj);
38365 return Py_BuildValue((char *)"");
38366 }
38367 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38368 PyObject *obj;
38369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38370 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38371 Py_INCREF(obj);
38372 return Py_BuildValue((char *)"");
38373 }
38374 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj;
38376 wxSizerItem *result;
38377 char *kwnames[] = {
38378 NULL
38379 };
38380
38381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38382 {
38383 PyThreadState* __tstate = wxPyBeginAllowThreads();
38384 result = (wxSizerItem *)new wxSizerItem();
38385
38386 wxPyEndAllowThreads(__tstate);
38387 if (PyErr_Occurred()) SWIG_fail;
38388 }
38389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38390 return resultobj;
38391 fail:
38392 return NULL;
38393 }
38394
38395
38396 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38397 PyObject *resultobj;
38398 wxWindow *arg1 = (wxWindow *) 0 ;
38399 int arg2 ;
38400 int arg3 ;
38401 int arg4 ;
38402 PyObject *arg5 = (PyObject *) NULL ;
38403 wxSizerItem *result;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 PyObject * obj2 = 0 ;
38407 PyObject * obj3 = 0 ;
38408 PyObject * obj4 = 0 ;
38409 char *kwnames[] = {
38410 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38411 };
38412
38413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38415 if (SWIG_arg_fail(1)) SWIG_fail;
38416 {
38417 arg2 = (int)(SWIG_As_int(obj1));
38418 if (SWIG_arg_fail(2)) SWIG_fail;
38419 }
38420 {
38421 arg3 = (int)(SWIG_As_int(obj2));
38422 if (SWIG_arg_fail(3)) SWIG_fail;
38423 }
38424 {
38425 arg4 = (int)(SWIG_As_int(obj3));
38426 if (SWIG_arg_fail(4)) SWIG_fail;
38427 }
38428 if (obj4) {
38429 arg5 = obj4;
38430 }
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38434
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38439 return resultobj;
38440 fail:
38441 return NULL;
38442 }
38443
38444
38445 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38446 PyObject *resultobj;
38447 int arg1 ;
38448 int arg2 ;
38449 int arg3 ;
38450 int arg4 ;
38451 int arg5 ;
38452 PyObject *arg6 = (PyObject *) NULL ;
38453 wxSizerItem *result;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 PyObject * obj2 = 0 ;
38457 PyObject * obj3 = 0 ;
38458 PyObject * obj4 = 0 ;
38459 PyObject * obj5 = 0 ;
38460 char *kwnames[] = {
38461 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38462 };
38463
38464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38465 {
38466 arg1 = (int)(SWIG_As_int(obj0));
38467 if (SWIG_arg_fail(1)) SWIG_fail;
38468 }
38469 {
38470 arg2 = (int)(SWIG_As_int(obj1));
38471 if (SWIG_arg_fail(2)) SWIG_fail;
38472 }
38473 {
38474 arg3 = (int)(SWIG_As_int(obj2));
38475 if (SWIG_arg_fail(3)) SWIG_fail;
38476 }
38477 {
38478 arg4 = (int)(SWIG_As_int(obj3));
38479 if (SWIG_arg_fail(4)) SWIG_fail;
38480 }
38481 {
38482 arg5 = (int)(SWIG_As_int(obj4));
38483 if (SWIG_arg_fail(5)) SWIG_fail;
38484 }
38485 if (obj5) {
38486 arg6 = obj5;
38487 }
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38491
38492 wxPyEndAllowThreads(__tstate);
38493 if (PyErr_Occurred()) SWIG_fail;
38494 }
38495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38496 return resultobj;
38497 fail:
38498 return NULL;
38499 }
38500
38501
38502 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38503 PyObject *resultobj;
38504 wxSizer *arg1 = (wxSizer *) 0 ;
38505 int arg2 ;
38506 int arg3 ;
38507 int arg4 ;
38508 PyObject *arg5 = (PyObject *) NULL ;
38509 wxSizerItem *result;
38510 PyObject * obj0 = 0 ;
38511 PyObject * obj1 = 0 ;
38512 PyObject * obj2 = 0 ;
38513 PyObject * obj3 = 0 ;
38514 PyObject * obj4 = 0 ;
38515 char *kwnames[] = {
38516 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38517 };
38518
38519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38521 if (SWIG_arg_fail(1)) SWIG_fail;
38522 {
38523 arg2 = (int)(SWIG_As_int(obj1));
38524 if (SWIG_arg_fail(2)) SWIG_fail;
38525 }
38526 {
38527 arg3 = (int)(SWIG_As_int(obj2));
38528 if (SWIG_arg_fail(3)) SWIG_fail;
38529 }
38530 {
38531 arg4 = (int)(SWIG_As_int(obj3));
38532 if (SWIG_arg_fail(4)) SWIG_fail;
38533 }
38534 if (obj4) {
38535 arg5 = obj4;
38536 }
38537 {
38538 PyThreadState* __tstate = wxPyBeginAllowThreads();
38539 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38540
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38545 return resultobj;
38546 fail:
38547 return NULL;
38548 }
38549
38550
38551 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj;
38553 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38554 PyObject * obj0 = 0 ;
38555 char *kwnames[] = {
38556 (char *) "self", NULL
38557 };
38558
38559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38561 if (SWIG_arg_fail(1)) SWIG_fail;
38562 {
38563 PyThreadState* __tstate = wxPyBeginAllowThreads();
38564 (arg1)->DeleteWindows();
38565
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 Py_INCREF(Py_None); resultobj = Py_None;
38570 return resultobj;
38571 fail:
38572 return NULL;
38573 }
38574
38575
38576 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38577 PyObject *resultobj;
38578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38579 PyObject * obj0 = 0 ;
38580 char *kwnames[] = {
38581 (char *) "self", NULL
38582 };
38583
38584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38586 if (SWIG_arg_fail(1)) SWIG_fail;
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 (arg1)->DetachSizer();
38590
38591 wxPyEndAllowThreads(__tstate);
38592 if (PyErr_Occurred()) SWIG_fail;
38593 }
38594 Py_INCREF(Py_None); resultobj = Py_None;
38595 return resultobj;
38596 fail:
38597 return NULL;
38598 }
38599
38600
38601 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38602 PyObject *resultobj;
38603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38604 wxSize result;
38605 PyObject * obj0 = 0 ;
38606 char *kwnames[] = {
38607 (char *) "self", NULL
38608 };
38609
38610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38612 if (SWIG_arg_fail(1)) SWIG_fail;
38613 {
38614 PyThreadState* __tstate = wxPyBeginAllowThreads();
38615 result = (arg1)->GetSize();
38616
38617 wxPyEndAllowThreads(__tstate);
38618 if (PyErr_Occurred()) SWIG_fail;
38619 }
38620 {
38621 wxSize * resultptr;
38622 resultptr = new wxSize((wxSize &)(result));
38623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38624 }
38625 return resultobj;
38626 fail:
38627 return NULL;
38628 }
38629
38630
38631 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38632 PyObject *resultobj;
38633 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38634 wxSize result;
38635 PyObject * obj0 = 0 ;
38636 char *kwnames[] = {
38637 (char *) "self", NULL
38638 };
38639
38640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38642 if (SWIG_arg_fail(1)) SWIG_fail;
38643 {
38644 PyThreadState* __tstate = wxPyBeginAllowThreads();
38645 result = (arg1)->CalcMin();
38646
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 {
38651 wxSize * resultptr;
38652 resultptr = new wxSize((wxSize &)(result));
38653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38654 }
38655 return resultobj;
38656 fail:
38657 return NULL;
38658 }
38659
38660
38661 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38662 PyObject *resultobj;
38663 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38664 wxPoint arg2 ;
38665 wxSize arg3 ;
38666 PyObject * obj0 = 0 ;
38667 PyObject * obj1 = 0 ;
38668 PyObject * obj2 = 0 ;
38669 char *kwnames[] = {
38670 (char *) "self",(char *) "pos",(char *) "size", NULL
38671 };
38672
38673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38675 if (SWIG_arg_fail(1)) SWIG_fail;
38676 {
38677 wxPoint * argp;
38678 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38679 if (SWIG_arg_fail(2)) SWIG_fail;
38680 if (argp == NULL) {
38681 SWIG_null_ref("wxPoint");
38682 }
38683 if (SWIG_arg_fail(2)) SWIG_fail;
38684 arg2 = *argp;
38685 }
38686 {
38687 wxSize * argp;
38688 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38689 if (SWIG_arg_fail(3)) SWIG_fail;
38690 if (argp == NULL) {
38691 SWIG_null_ref("wxSize");
38692 }
38693 if (SWIG_arg_fail(3)) SWIG_fail;
38694 arg3 = *argp;
38695 }
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 (arg1)->SetDimension(arg2,arg3);
38699
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 Py_INCREF(Py_None); resultobj = Py_None;
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj;
38712 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38713 wxSize result;
38714 PyObject * obj0 = 0 ;
38715 char *kwnames[] = {
38716 (char *) "self", NULL
38717 };
38718
38719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38721 if (SWIG_arg_fail(1)) SWIG_fail;
38722 {
38723 PyThreadState* __tstate = wxPyBeginAllowThreads();
38724 result = (arg1)->GetMinSize();
38725
38726 wxPyEndAllowThreads(__tstate);
38727 if (PyErr_Occurred()) SWIG_fail;
38728 }
38729 {
38730 wxSize * resultptr;
38731 resultptr = new wxSize((wxSize &)(result));
38732 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38733 }
38734 return resultobj;
38735 fail:
38736 return NULL;
38737 }
38738
38739
38740 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38741 PyObject *resultobj;
38742 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38743 wxSize result;
38744 PyObject * obj0 = 0 ;
38745 char *kwnames[] = {
38746 (char *) "self", NULL
38747 };
38748
38749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38751 if (SWIG_arg_fail(1)) SWIG_fail;
38752 {
38753 PyThreadState* __tstate = wxPyBeginAllowThreads();
38754 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38755
38756 wxPyEndAllowThreads(__tstate);
38757 if (PyErr_Occurred()) SWIG_fail;
38758 }
38759 {
38760 wxSize * resultptr;
38761 resultptr = new wxSize((wxSize &)(result));
38762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38763 }
38764 return resultobj;
38765 fail:
38766 return NULL;
38767 }
38768
38769
38770 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38771 PyObject *resultobj;
38772 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38773 int arg2 ;
38774 int arg3 ;
38775 PyObject * obj0 = 0 ;
38776 PyObject * obj1 = 0 ;
38777 PyObject * obj2 = 0 ;
38778 char *kwnames[] = {
38779 (char *) "self",(char *) "x",(char *) "y", NULL
38780 };
38781
38782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38784 if (SWIG_arg_fail(1)) SWIG_fail;
38785 {
38786 arg2 = (int)(SWIG_As_int(obj1));
38787 if (SWIG_arg_fail(2)) SWIG_fail;
38788 }
38789 {
38790 arg3 = (int)(SWIG_As_int(obj2));
38791 if (SWIG_arg_fail(3)) SWIG_fail;
38792 }
38793 {
38794 PyThreadState* __tstate = wxPyBeginAllowThreads();
38795 (arg1)->SetInitSize(arg2,arg3);
38796
38797 wxPyEndAllowThreads(__tstate);
38798 if (PyErr_Occurred()) SWIG_fail;
38799 }
38800 Py_INCREF(Py_None); resultobj = Py_None;
38801 return resultobj;
38802 fail:
38803 return NULL;
38804 }
38805
38806
38807 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38808 PyObject *resultobj;
38809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38810 int arg2 ;
38811 int arg3 ;
38812 PyObject * obj0 = 0 ;
38813 PyObject * obj1 = 0 ;
38814 PyObject * obj2 = 0 ;
38815 char *kwnames[] = {
38816 (char *) "self",(char *) "width",(char *) "height", NULL
38817 };
38818
38819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38821 if (SWIG_arg_fail(1)) SWIG_fail;
38822 {
38823 arg2 = (int)(SWIG_As_int(obj1));
38824 if (SWIG_arg_fail(2)) SWIG_fail;
38825 }
38826 {
38827 arg3 = (int)(SWIG_As_int(obj2));
38828 if (SWIG_arg_fail(3)) SWIG_fail;
38829 }
38830 {
38831 PyThreadState* __tstate = wxPyBeginAllowThreads();
38832 (arg1)->SetRatio(arg2,arg3);
38833
38834 wxPyEndAllowThreads(__tstate);
38835 if (PyErr_Occurred()) SWIG_fail;
38836 }
38837 Py_INCREF(Py_None); resultobj = Py_None;
38838 return resultobj;
38839 fail:
38840 return NULL;
38841 }
38842
38843
38844 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38845 PyObject *resultobj;
38846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38847 wxSize *arg2 = 0 ;
38848 wxSize temp2 ;
38849 PyObject * obj0 = 0 ;
38850 PyObject * obj1 = 0 ;
38851 char *kwnames[] = {
38852 (char *) "self",(char *) "size", NULL
38853 };
38854
38855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38857 if (SWIG_arg_fail(1)) SWIG_fail;
38858 {
38859 arg2 = &temp2;
38860 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38861 }
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 (arg1)->SetRatio((wxSize const &)*arg2);
38865
38866 wxPyEndAllowThreads(__tstate);
38867 if (PyErr_Occurred()) SWIG_fail;
38868 }
38869 Py_INCREF(Py_None); resultobj = Py_None;
38870 return resultobj;
38871 fail:
38872 return NULL;
38873 }
38874
38875
38876 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj;
38878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38879 float arg2 ;
38880 PyObject * obj0 = 0 ;
38881 PyObject * obj1 = 0 ;
38882 char *kwnames[] = {
38883 (char *) "self",(char *) "ratio", NULL
38884 };
38885
38886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38888 if (SWIG_arg_fail(1)) SWIG_fail;
38889 {
38890 arg2 = (float)(SWIG_As_float(obj1));
38891 if (SWIG_arg_fail(2)) SWIG_fail;
38892 }
38893 {
38894 PyThreadState* __tstate = wxPyBeginAllowThreads();
38895 (arg1)->SetRatio(arg2);
38896
38897 wxPyEndAllowThreads(__tstate);
38898 if (PyErr_Occurred()) SWIG_fail;
38899 }
38900 Py_INCREF(Py_None); resultobj = Py_None;
38901 return resultobj;
38902 fail:
38903 return NULL;
38904 }
38905
38906
38907 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38908 PyObject *resultobj;
38909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38910 float result;
38911 PyObject * obj0 = 0 ;
38912 char *kwnames[] = {
38913 (char *) "self", NULL
38914 };
38915
38916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38918 if (SWIG_arg_fail(1)) SWIG_fail;
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 result = (float)(arg1)->GetRatio();
38922
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 {
38927 resultobj = SWIG_From_float((float)(result));
38928 }
38929 return resultobj;
38930 fail:
38931 return NULL;
38932 }
38933
38934
38935 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38936 PyObject *resultobj;
38937 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38938 wxRect result;
38939 PyObject * obj0 = 0 ;
38940 char *kwnames[] = {
38941 (char *) "self", NULL
38942 };
38943
38944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38946 if (SWIG_arg_fail(1)) SWIG_fail;
38947 {
38948 PyThreadState* __tstate = wxPyBeginAllowThreads();
38949 result = (arg1)->GetRect();
38950
38951 wxPyEndAllowThreads(__tstate);
38952 if (PyErr_Occurred()) SWIG_fail;
38953 }
38954 {
38955 wxRect * resultptr;
38956 resultptr = new wxRect((wxRect &)(result));
38957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38958 }
38959 return resultobj;
38960 fail:
38961 return NULL;
38962 }
38963
38964
38965 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38966 PyObject *resultobj;
38967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38968 bool result;
38969 PyObject * obj0 = 0 ;
38970 char *kwnames[] = {
38971 (char *) "self", NULL
38972 };
38973
38974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38976 if (SWIG_arg_fail(1)) SWIG_fail;
38977 {
38978 PyThreadState* __tstate = wxPyBeginAllowThreads();
38979 result = (bool)(arg1)->IsWindow();
38980
38981 wxPyEndAllowThreads(__tstate);
38982 if (PyErr_Occurred()) SWIG_fail;
38983 }
38984 {
38985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38986 }
38987 return resultobj;
38988 fail:
38989 return NULL;
38990 }
38991
38992
38993 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38994 PyObject *resultobj;
38995 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38996 bool result;
38997 PyObject * obj0 = 0 ;
38998 char *kwnames[] = {
38999 (char *) "self", NULL
39000 };
39001
39002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39004 if (SWIG_arg_fail(1)) SWIG_fail;
39005 {
39006 PyThreadState* __tstate = wxPyBeginAllowThreads();
39007 result = (bool)(arg1)->IsSizer();
39008
39009 wxPyEndAllowThreads(__tstate);
39010 if (PyErr_Occurred()) SWIG_fail;
39011 }
39012 {
39013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39014 }
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj;
39023 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39024 bool result;
39025 PyObject * obj0 = 0 ;
39026 char *kwnames[] = {
39027 (char *) "self", NULL
39028 };
39029
39030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39032 if (SWIG_arg_fail(1)) SWIG_fail;
39033 {
39034 PyThreadState* __tstate = wxPyBeginAllowThreads();
39035 result = (bool)(arg1)->IsSpacer();
39036
39037 wxPyEndAllowThreads(__tstate);
39038 if (PyErr_Occurred()) SWIG_fail;
39039 }
39040 {
39041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39042 }
39043 return resultobj;
39044 fail:
39045 return NULL;
39046 }
39047
39048
39049 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39050 PyObject *resultobj;
39051 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39052 int arg2 ;
39053 PyObject * obj0 = 0 ;
39054 PyObject * obj1 = 0 ;
39055 char *kwnames[] = {
39056 (char *) "self",(char *) "proportion", NULL
39057 };
39058
39059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39061 if (SWIG_arg_fail(1)) SWIG_fail;
39062 {
39063 arg2 = (int)(SWIG_As_int(obj1));
39064 if (SWIG_arg_fail(2)) SWIG_fail;
39065 }
39066 {
39067 PyThreadState* __tstate = wxPyBeginAllowThreads();
39068 (arg1)->SetProportion(arg2);
39069
39070 wxPyEndAllowThreads(__tstate);
39071 if (PyErr_Occurred()) SWIG_fail;
39072 }
39073 Py_INCREF(Py_None); resultobj = Py_None;
39074 return resultobj;
39075 fail:
39076 return NULL;
39077 }
39078
39079
39080 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39081 PyObject *resultobj;
39082 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39083 int result;
39084 PyObject * obj0 = 0 ;
39085 char *kwnames[] = {
39086 (char *) "self", NULL
39087 };
39088
39089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39091 if (SWIG_arg_fail(1)) SWIG_fail;
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (int)(arg1)->GetProportion();
39095
39096 wxPyEndAllowThreads(__tstate);
39097 if (PyErr_Occurred()) SWIG_fail;
39098 }
39099 {
39100 resultobj = SWIG_From_int((int)(result));
39101 }
39102 return resultobj;
39103 fail:
39104 return NULL;
39105 }
39106
39107
39108 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39109 PyObject *resultobj;
39110 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39111 int arg2 ;
39112 PyObject * obj0 = 0 ;
39113 PyObject * obj1 = 0 ;
39114 char *kwnames[] = {
39115 (char *) "self",(char *) "flag", NULL
39116 };
39117
39118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39120 if (SWIG_arg_fail(1)) SWIG_fail;
39121 {
39122 arg2 = (int)(SWIG_As_int(obj1));
39123 if (SWIG_arg_fail(2)) SWIG_fail;
39124 }
39125 {
39126 PyThreadState* __tstate = wxPyBeginAllowThreads();
39127 (arg1)->SetFlag(arg2);
39128
39129 wxPyEndAllowThreads(__tstate);
39130 if (PyErr_Occurred()) SWIG_fail;
39131 }
39132 Py_INCREF(Py_None); resultobj = Py_None;
39133 return resultobj;
39134 fail:
39135 return NULL;
39136 }
39137
39138
39139 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39140 PyObject *resultobj;
39141 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39142 int result;
39143 PyObject * obj0 = 0 ;
39144 char *kwnames[] = {
39145 (char *) "self", NULL
39146 };
39147
39148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39150 if (SWIG_arg_fail(1)) SWIG_fail;
39151 {
39152 PyThreadState* __tstate = wxPyBeginAllowThreads();
39153 result = (int)(arg1)->GetFlag();
39154
39155 wxPyEndAllowThreads(__tstate);
39156 if (PyErr_Occurred()) SWIG_fail;
39157 }
39158 {
39159 resultobj = SWIG_From_int((int)(result));
39160 }
39161 return resultobj;
39162 fail:
39163 return NULL;
39164 }
39165
39166
39167 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39168 PyObject *resultobj;
39169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39170 int arg2 ;
39171 PyObject * obj0 = 0 ;
39172 PyObject * obj1 = 0 ;
39173 char *kwnames[] = {
39174 (char *) "self",(char *) "border", NULL
39175 };
39176
39177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39179 if (SWIG_arg_fail(1)) SWIG_fail;
39180 {
39181 arg2 = (int)(SWIG_As_int(obj1));
39182 if (SWIG_arg_fail(2)) SWIG_fail;
39183 }
39184 {
39185 PyThreadState* __tstate = wxPyBeginAllowThreads();
39186 (arg1)->SetBorder(arg2);
39187
39188 wxPyEndAllowThreads(__tstate);
39189 if (PyErr_Occurred()) SWIG_fail;
39190 }
39191 Py_INCREF(Py_None); resultobj = Py_None;
39192 return resultobj;
39193 fail:
39194 return NULL;
39195 }
39196
39197
39198 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39199 PyObject *resultobj;
39200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39201 int result;
39202 PyObject * obj0 = 0 ;
39203 char *kwnames[] = {
39204 (char *) "self", NULL
39205 };
39206
39207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39209 if (SWIG_arg_fail(1)) SWIG_fail;
39210 {
39211 PyThreadState* __tstate = wxPyBeginAllowThreads();
39212 result = (int)(arg1)->GetBorder();
39213
39214 wxPyEndAllowThreads(__tstate);
39215 if (PyErr_Occurred()) SWIG_fail;
39216 }
39217 {
39218 resultobj = SWIG_From_int((int)(result));
39219 }
39220 return resultobj;
39221 fail:
39222 return NULL;
39223 }
39224
39225
39226 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39227 PyObject *resultobj;
39228 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39229 wxWindow *result;
39230 PyObject * obj0 = 0 ;
39231 char *kwnames[] = {
39232 (char *) "self", NULL
39233 };
39234
39235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39237 if (SWIG_arg_fail(1)) SWIG_fail;
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 result = (wxWindow *)(arg1)->GetWindow();
39241
39242 wxPyEndAllowThreads(__tstate);
39243 if (PyErr_Occurred()) SWIG_fail;
39244 }
39245 {
39246 resultobj = wxPyMake_wxObject(result, 0);
39247 }
39248 return resultobj;
39249 fail:
39250 return NULL;
39251 }
39252
39253
39254 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39255 PyObject *resultobj;
39256 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39257 wxWindow *arg2 = (wxWindow *) 0 ;
39258 PyObject * obj0 = 0 ;
39259 PyObject * obj1 = 0 ;
39260 char *kwnames[] = {
39261 (char *) "self",(char *) "window", NULL
39262 };
39263
39264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39266 if (SWIG_arg_fail(1)) SWIG_fail;
39267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39268 if (SWIG_arg_fail(2)) SWIG_fail;
39269 {
39270 PyThreadState* __tstate = wxPyBeginAllowThreads();
39271 (arg1)->SetWindow(arg2);
39272
39273 wxPyEndAllowThreads(__tstate);
39274 if (PyErr_Occurred()) SWIG_fail;
39275 }
39276 Py_INCREF(Py_None); resultobj = Py_None;
39277 return resultobj;
39278 fail:
39279 return NULL;
39280 }
39281
39282
39283 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39284 PyObject *resultobj;
39285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39286 wxSizer *result;
39287 PyObject * obj0 = 0 ;
39288 char *kwnames[] = {
39289 (char *) "self", NULL
39290 };
39291
39292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39294 if (SWIG_arg_fail(1)) SWIG_fail;
39295 {
39296 PyThreadState* __tstate = wxPyBeginAllowThreads();
39297 result = (wxSizer *)(arg1)->GetSizer();
39298
39299 wxPyEndAllowThreads(__tstate);
39300 if (PyErr_Occurred()) SWIG_fail;
39301 }
39302 {
39303 resultobj = wxPyMake_wxSizer(result, 0);
39304 }
39305 return resultobj;
39306 fail:
39307 return NULL;
39308 }
39309
39310
39311 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39312 PyObject *resultobj;
39313 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39314 wxSizer *arg2 = (wxSizer *) 0 ;
39315 PyObject * obj0 = 0 ;
39316 PyObject * obj1 = 0 ;
39317 char *kwnames[] = {
39318 (char *) "self",(char *) "sizer", NULL
39319 };
39320
39321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39323 if (SWIG_arg_fail(1)) SWIG_fail;
39324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39325 if (SWIG_arg_fail(2)) SWIG_fail;
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 (arg1)->SetSizer(arg2);
39329
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 Py_INCREF(Py_None); resultobj = Py_None;
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj;
39342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39343 wxSize *result;
39344 PyObject * obj0 = 0 ;
39345 char *kwnames[] = {
39346 (char *) "self", NULL
39347 };
39348
39349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39351 if (SWIG_arg_fail(1)) SWIG_fail;
39352 {
39353 PyThreadState* __tstate = wxPyBeginAllowThreads();
39354 {
39355 wxSize const &_result_ref = (arg1)->GetSpacer();
39356 result = (wxSize *) &_result_ref;
39357 }
39358
39359 wxPyEndAllowThreads(__tstate);
39360 if (PyErr_Occurred()) SWIG_fail;
39361 }
39362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39363 return resultobj;
39364 fail:
39365 return NULL;
39366 }
39367
39368
39369 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39370 PyObject *resultobj;
39371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39372 wxSize *arg2 = 0 ;
39373 wxSize temp2 ;
39374 PyObject * obj0 = 0 ;
39375 PyObject * obj1 = 0 ;
39376 char *kwnames[] = {
39377 (char *) "self",(char *) "size", NULL
39378 };
39379
39380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39382 if (SWIG_arg_fail(1)) SWIG_fail;
39383 {
39384 arg2 = &temp2;
39385 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39386 }
39387 {
39388 PyThreadState* __tstate = wxPyBeginAllowThreads();
39389 (arg1)->SetSpacer((wxSize const &)*arg2);
39390
39391 wxPyEndAllowThreads(__tstate);
39392 if (PyErr_Occurred()) SWIG_fail;
39393 }
39394 Py_INCREF(Py_None); resultobj = Py_None;
39395 return resultobj;
39396 fail:
39397 return NULL;
39398 }
39399
39400
39401 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39402 PyObject *resultobj;
39403 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39404 bool arg2 ;
39405 PyObject * obj0 = 0 ;
39406 PyObject * obj1 = 0 ;
39407 char *kwnames[] = {
39408 (char *) "self",(char *) "show", NULL
39409 };
39410
39411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39413 if (SWIG_arg_fail(1)) SWIG_fail;
39414 {
39415 arg2 = (bool)(SWIG_As_bool(obj1));
39416 if (SWIG_arg_fail(2)) SWIG_fail;
39417 }
39418 {
39419 PyThreadState* __tstate = wxPyBeginAllowThreads();
39420 (arg1)->Show(arg2);
39421
39422 wxPyEndAllowThreads(__tstate);
39423 if (PyErr_Occurred()) SWIG_fail;
39424 }
39425 Py_INCREF(Py_None); resultobj = Py_None;
39426 return resultobj;
39427 fail:
39428 return NULL;
39429 }
39430
39431
39432 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39433 PyObject *resultobj;
39434 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39435 bool result;
39436 PyObject * obj0 = 0 ;
39437 char *kwnames[] = {
39438 (char *) "self", NULL
39439 };
39440
39441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39443 if (SWIG_arg_fail(1)) SWIG_fail;
39444 {
39445 PyThreadState* __tstate = wxPyBeginAllowThreads();
39446 result = (bool)(arg1)->IsShown();
39447
39448 wxPyEndAllowThreads(__tstate);
39449 if (PyErr_Occurred()) SWIG_fail;
39450 }
39451 {
39452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39453 }
39454 return resultobj;
39455 fail:
39456 return NULL;
39457 }
39458
39459
39460 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39461 PyObject *resultobj;
39462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39463 wxPoint result;
39464 PyObject * obj0 = 0 ;
39465 char *kwnames[] = {
39466 (char *) "self", NULL
39467 };
39468
39469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39471 if (SWIG_arg_fail(1)) SWIG_fail;
39472 {
39473 PyThreadState* __tstate = wxPyBeginAllowThreads();
39474 result = (arg1)->GetPosition();
39475
39476 wxPyEndAllowThreads(__tstate);
39477 if (PyErr_Occurred()) SWIG_fail;
39478 }
39479 {
39480 wxPoint * resultptr;
39481 resultptr = new wxPoint((wxPoint &)(result));
39482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39483 }
39484 return resultobj;
39485 fail:
39486 return NULL;
39487 }
39488
39489
39490 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39491 PyObject *resultobj;
39492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39493 PyObject *result;
39494 PyObject * obj0 = 0 ;
39495 char *kwnames[] = {
39496 (char *) "self", NULL
39497 };
39498
39499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39501 if (SWIG_arg_fail(1)) SWIG_fail;
39502 {
39503 PyThreadState* __tstate = wxPyBeginAllowThreads();
39504 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39505
39506 wxPyEndAllowThreads(__tstate);
39507 if (PyErr_Occurred()) SWIG_fail;
39508 }
39509 resultobj = result;
39510 return resultobj;
39511 fail:
39512 return NULL;
39513 }
39514
39515
39516 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39517 PyObject *obj;
39518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39519 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39520 Py_INCREF(obj);
39521 return Py_BuildValue((char *)"");
39522 }
39523 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39524 PyObject *resultobj;
39525 wxSizer *arg1 = (wxSizer *) 0 ;
39526 PyObject *arg2 = (PyObject *) 0 ;
39527 PyObject * obj0 = 0 ;
39528 PyObject * obj1 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self",(char *) "_self", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 arg2 = obj1;
39537 {
39538 PyThreadState* __tstate = wxPyBeginAllowThreads();
39539 wxSizer__setOORInfo(arg1,arg2);
39540
39541 wxPyEndAllowThreads(__tstate);
39542 if (PyErr_Occurred()) SWIG_fail;
39543 }
39544 Py_INCREF(Py_None); resultobj = Py_None;
39545 return resultobj;
39546 fail:
39547 return NULL;
39548 }
39549
39550
39551 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39552 PyObject *resultobj;
39553 wxSizer *arg1 = (wxSizer *) 0 ;
39554 PyObject *arg2 = (PyObject *) 0 ;
39555 int arg3 = (int) 0 ;
39556 int arg4 = (int) 0 ;
39557 int arg5 = (int) 0 ;
39558 PyObject *arg6 = (PyObject *) NULL ;
39559 wxSizerItem *result;
39560 PyObject * obj0 = 0 ;
39561 PyObject * obj1 = 0 ;
39562 PyObject * obj2 = 0 ;
39563 PyObject * obj3 = 0 ;
39564 PyObject * obj4 = 0 ;
39565 PyObject * obj5 = 0 ;
39566 char *kwnames[] = {
39567 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39568 };
39569
39570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39572 if (SWIG_arg_fail(1)) SWIG_fail;
39573 arg2 = obj1;
39574 if (obj2) {
39575 {
39576 arg3 = (int)(SWIG_As_int(obj2));
39577 if (SWIG_arg_fail(3)) SWIG_fail;
39578 }
39579 }
39580 if (obj3) {
39581 {
39582 arg4 = (int)(SWIG_As_int(obj3));
39583 if (SWIG_arg_fail(4)) SWIG_fail;
39584 }
39585 }
39586 if (obj4) {
39587 {
39588 arg5 = (int)(SWIG_As_int(obj4));
39589 if (SWIG_arg_fail(5)) SWIG_fail;
39590 }
39591 }
39592 if (obj5) {
39593 arg6 = obj5;
39594 }
39595 {
39596 PyThreadState* __tstate = wxPyBeginAllowThreads();
39597 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39598
39599 wxPyEndAllowThreads(__tstate);
39600 if (PyErr_Occurred()) SWIG_fail;
39601 }
39602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39603 return resultobj;
39604 fail:
39605 return NULL;
39606 }
39607
39608
39609 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39610 PyObject *resultobj;
39611 wxSizer *arg1 = (wxSizer *) 0 ;
39612 int arg2 ;
39613 PyObject *arg3 = (PyObject *) 0 ;
39614 int arg4 = (int) 0 ;
39615 int arg5 = (int) 0 ;
39616 int arg6 = (int) 0 ;
39617 PyObject *arg7 = (PyObject *) NULL ;
39618 wxSizerItem *result;
39619 PyObject * obj0 = 0 ;
39620 PyObject * obj1 = 0 ;
39621 PyObject * obj2 = 0 ;
39622 PyObject * obj3 = 0 ;
39623 PyObject * obj4 = 0 ;
39624 PyObject * obj5 = 0 ;
39625 PyObject * obj6 = 0 ;
39626 char *kwnames[] = {
39627 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39628 };
39629
39630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39632 if (SWIG_arg_fail(1)) SWIG_fail;
39633 {
39634 arg2 = (int)(SWIG_As_int(obj1));
39635 if (SWIG_arg_fail(2)) SWIG_fail;
39636 }
39637 arg3 = obj2;
39638 if (obj3) {
39639 {
39640 arg4 = (int)(SWIG_As_int(obj3));
39641 if (SWIG_arg_fail(4)) SWIG_fail;
39642 }
39643 }
39644 if (obj4) {
39645 {
39646 arg5 = (int)(SWIG_As_int(obj4));
39647 if (SWIG_arg_fail(5)) SWIG_fail;
39648 }
39649 }
39650 if (obj5) {
39651 {
39652 arg6 = (int)(SWIG_As_int(obj5));
39653 if (SWIG_arg_fail(6)) SWIG_fail;
39654 }
39655 }
39656 if (obj6) {
39657 arg7 = obj6;
39658 }
39659 {
39660 PyThreadState* __tstate = wxPyBeginAllowThreads();
39661 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39662
39663 wxPyEndAllowThreads(__tstate);
39664 if (PyErr_Occurred()) SWIG_fail;
39665 }
39666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39667 return resultobj;
39668 fail:
39669 return NULL;
39670 }
39671
39672
39673 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39674 PyObject *resultobj;
39675 wxSizer *arg1 = (wxSizer *) 0 ;
39676 PyObject *arg2 = (PyObject *) 0 ;
39677 int arg3 = (int) 0 ;
39678 int arg4 = (int) 0 ;
39679 int arg5 = (int) 0 ;
39680 PyObject *arg6 = (PyObject *) NULL ;
39681 wxSizerItem *result;
39682 PyObject * obj0 = 0 ;
39683 PyObject * obj1 = 0 ;
39684 PyObject * obj2 = 0 ;
39685 PyObject * obj3 = 0 ;
39686 PyObject * obj4 = 0 ;
39687 PyObject * obj5 = 0 ;
39688 char *kwnames[] = {
39689 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39690 };
39691
39692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39694 if (SWIG_arg_fail(1)) SWIG_fail;
39695 arg2 = obj1;
39696 if (obj2) {
39697 {
39698 arg3 = (int)(SWIG_As_int(obj2));
39699 if (SWIG_arg_fail(3)) SWIG_fail;
39700 }
39701 }
39702 if (obj3) {
39703 {
39704 arg4 = (int)(SWIG_As_int(obj3));
39705 if (SWIG_arg_fail(4)) SWIG_fail;
39706 }
39707 }
39708 if (obj4) {
39709 {
39710 arg5 = (int)(SWIG_As_int(obj4));
39711 if (SWIG_arg_fail(5)) SWIG_fail;
39712 }
39713 }
39714 if (obj5) {
39715 arg6 = obj5;
39716 }
39717 {
39718 PyThreadState* __tstate = wxPyBeginAllowThreads();
39719 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39720
39721 wxPyEndAllowThreads(__tstate);
39722 if (PyErr_Occurred()) SWIG_fail;
39723 }
39724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39725 return resultobj;
39726 fail:
39727 return NULL;
39728 }
39729
39730
39731 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39732 PyObject *resultobj;
39733 wxSizer *arg1 = (wxSizer *) 0 ;
39734 PyObject *arg2 = (PyObject *) 0 ;
39735 bool result;
39736 PyObject * obj0 = 0 ;
39737 PyObject * obj1 = 0 ;
39738 char *kwnames[] = {
39739 (char *) "self",(char *) "item", NULL
39740 };
39741
39742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39744 if (SWIG_arg_fail(1)) SWIG_fail;
39745 arg2 = obj1;
39746 {
39747 PyThreadState* __tstate = wxPyBeginAllowThreads();
39748 result = (bool)wxSizer_Remove(arg1,arg2);
39749
39750 wxPyEndAllowThreads(__tstate);
39751 if (PyErr_Occurred()) SWIG_fail;
39752 }
39753 {
39754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39755 }
39756 return resultobj;
39757 fail:
39758 return NULL;
39759 }
39760
39761
39762 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj;
39764 wxSizer *arg1 = (wxSizer *) 0 ;
39765 PyObject *arg2 = (PyObject *) 0 ;
39766 bool result;
39767 PyObject * obj0 = 0 ;
39768 PyObject * obj1 = 0 ;
39769 char *kwnames[] = {
39770 (char *) "self",(char *) "item", NULL
39771 };
39772
39773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39775 if (SWIG_arg_fail(1)) SWIG_fail;
39776 arg2 = obj1;
39777 {
39778 PyThreadState* __tstate = wxPyBeginAllowThreads();
39779 result = (bool)wxSizer_Detach(arg1,arg2);
39780
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 {
39785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39786 }
39787 return resultobj;
39788 fail:
39789 return NULL;
39790 }
39791
39792
39793 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39794 PyObject *resultobj;
39795 wxSizer *arg1 = (wxSizer *) 0 ;
39796 PyObject *arg2 = (PyObject *) 0 ;
39797 wxSizerItem *result;
39798 PyObject * obj0 = 0 ;
39799 PyObject * obj1 = 0 ;
39800 char *kwnames[] = {
39801 (char *) "self",(char *) "item", NULL
39802 };
39803
39804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39806 if (SWIG_arg_fail(1)) SWIG_fail;
39807 arg2 = obj1;
39808 {
39809 PyThreadState* __tstate = wxPyBeginAllowThreads();
39810 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39811
39812 wxPyEndAllowThreads(__tstate);
39813 if (PyErr_Occurred()) SWIG_fail;
39814 }
39815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39816 return resultobj;
39817 fail:
39818 return NULL;
39819 }
39820
39821
39822 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj;
39824 wxSizer *arg1 = (wxSizer *) 0 ;
39825 PyObject *arg2 = (PyObject *) 0 ;
39826 wxSize *arg3 = 0 ;
39827 wxSize temp3 ;
39828 PyObject * obj0 = 0 ;
39829 PyObject * obj1 = 0 ;
39830 PyObject * obj2 = 0 ;
39831 char *kwnames[] = {
39832 (char *) "self",(char *) "item",(char *) "size", NULL
39833 };
39834
39835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39837 if (SWIG_arg_fail(1)) SWIG_fail;
39838 arg2 = obj1;
39839 {
39840 arg3 = &temp3;
39841 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39842 }
39843 {
39844 PyThreadState* __tstate = wxPyBeginAllowThreads();
39845 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39846
39847 wxPyEndAllowThreads(__tstate);
39848 if (PyErr_Occurred()) SWIG_fail;
39849 }
39850 Py_INCREF(Py_None); resultobj = Py_None;
39851 return resultobj;
39852 fail:
39853 return NULL;
39854 }
39855
39856
39857 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39858 PyObject *resultobj;
39859 wxSizer *arg1 = (wxSizer *) 0 ;
39860 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39861 wxSizerItem *result;
39862 PyObject * obj0 = 0 ;
39863 PyObject * obj1 = 0 ;
39864 char *kwnames[] = {
39865 (char *) "self",(char *) "item", NULL
39866 };
39867
39868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39870 if (SWIG_arg_fail(1)) SWIG_fail;
39871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39872 if (SWIG_arg_fail(2)) SWIG_fail;
39873 {
39874 PyThreadState* __tstate = wxPyBeginAllowThreads();
39875 result = (wxSizerItem *)(arg1)->Add(arg2);
39876
39877 wxPyEndAllowThreads(__tstate);
39878 if (PyErr_Occurred()) SWIG_fail;
39879 }
39880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39881 return resultobj;
39882 fail:
39883 return NULL;
39884 }
39885
39886
39887 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39888 PyObject *resultobj;
39889 wxSizer *arg1 = (wxSizer *) 0 ;
39890 size_t arg2 ;
39891 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39892 wxSizerItem *result;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 PyObject * obj2 = 0 ;
39896 char *kwnames[] = {
39897 (char *) "self",(char *) "index",(char *) "item", NULL
39898 };
39899
39900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39902 if (SWIG_arg_fail(1)) SWIG_fail;
39903 {
39904 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39905 if (SWIG_arg_fail(2)) SWIG_fail;
39906 }
39907 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(3)) SWIG_fail;
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39912
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39917 return resultobj;
39918 fail:
39919 return NULL;
39920 }
39921
39922
39923 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39924 PyObject *resultobj;
39925 wxSizer *arg1 = (wxSizer *) 0 ;
39926 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39927 wxSizerItem *result;
39928 PyObject * obj0 = 0 ;
39929 PyObject * obj1 = 0 ;
39930 char *kwnames[] = {
39931 (char *) "self",(char *) "item", NULL
39932 };
39933
39934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39936 if (SWIG_arg_fail(1)) SWIG_fail;
39937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39938 if (SWIG_arg_fail(2)) SWIG_fail;
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39942
39943 wxPyEndAllowThreads(__tstate);
39944 if (PyErr_Occurred()) SWIG_fail;
39945 }
39946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj;
39955 wxSizer *arg1 = (wxSizer *) 0 ;
39956 int arg2 ;
39957 int arg3 ;
39958 int arg4 ;
39959 int arg5 ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 PyObject * obj2 = 0 ;
39963 PyObject * obj3 = 0 ;
39964 PyObject * obj4 = 0 ;
39965 char *kwnames[] = {
39966 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39967 };
39968
39969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39971 if (SWIG_arg_fail(1)) SWIG_fail;
39972 {
39973 arg2 = (int)(SWIG_As_int(obj1));
39974 if (SWIG_arg_fail(2)) SWIG_fail;
39975 }
39976 {
39977 arg3 = (int)(SWIG_As_int(obj2));
39978 if (SWIG_arg_fail(3)) SWIG_fail;
39979 }
39980 {
39981 arg4 = (int)(SWIG_As_int(obj3));
39982 if (SWIG_arg_fail(4)) SWIG_fail;
39983 }
39984 {
39985 arg5 = (int)(SWIG_As_int(obj4));
39986 if (SWIG_arg_fail(5)) SWIG_fail;
39987 }
39988 {
39989 PyThreadState* __tstate = wxPyBeginAllowThreads();
39990 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39991
39992 wxPyEndAllowThreads(__tstate);
39993 if (PyErr_Occurred()) SWIG_fail;
39994 }
39995 Py_INCREF(Py_None); resultobj = Py_None;
39996 return resultobj;
39997 fail:
39998 return NULL;
39999 }
40000
40001
40002 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40003 PyObject *resultobj;
40004 wxSizer *arg1 = (wxSizer *) 0 ;
40005 wxSize *arg2 = 0 ;
40006 wxSize temp2 ;
40007 PyObject * obj0 = 0 ;
40008 PyObject * obj1 = 0 ;
40009 char *kwnames[] = {
40010 (char *) "self",(char *) "size", NULL
40011 };
40012
40013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40015 if (SWIG_arg_fail(1)) SWIG_fail;
40016 {
40017 arg2 = &temp2;
40018 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40019 }
40020 {
40021 PyThreadState* __tstate = wxPyBeginAllowThreads();
40022 (arg1)->SetMinSize((wxSize const &)*arg2);
40023
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 Py_INCREF(Py_None); resultobj = Py_None;
40028 return resultobj;
40029 fail:
40030 return NULL;
40031 }
40032
40033
40034 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40035 PyObject *resultobj;
40036 wxSizer *arg1 = (wxSizer *) 0 ;
40037 wxSize result;
40038 PyObject * obj0 = 0 ;
40039 char *kwnames[] = {
40040 (char *) "self", NULL
40041 };
40042
40043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40045 if (SWIG_arg_fail(1)) SWIG_fail;
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (arg1)->GetSize();
40049
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 {
40054 wxSize * resultptr;
40055 resultptr = new wxSize((wxSize &)(result));
40056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40057 }
40058 return resultobj;
40059 fail:
40060 return NULL;
40061 }
40062
40063
40064 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40065 PyObject *resultobj;
40066 wxSizer *arg1 = (wxSizer *) 0 ;
40067 wxPoint result;
40068 PyObject * obj0 = 0 ;
40069 char *kwnames[] = {
40070 (char *) "self", NULL
40071 };
40072
40073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40075 if (SWIG_arg_fail(1)) SWIG_fail;
40076 {
40077 PyThreadState* __tstate = wxPyBeginAllowThreads();
40078 result = (arg1)->GetPosition();
40079
40080 wxPyEndAllowThreads(__tstate);
40081 if (PyErr_Occurred()) SWIG_fail;
40082 }
40083 {
40084 wxPoint * resultptr;
40085 resultptr = new wxPoint((wxPoint &)(result));
40086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40087 }
40088 return resultobj;
40089 fail:
40090 return NULL;
40091 }
40092
40093
40094 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40095 PyObject *resultobj;
40096 wxSizer *arg1 = (wxSizer *) 0 ;
40097 wxSize result;
40098 PyObject * obj0 = 0 ;
40099 char *kwnames[] = {
40100 (char *) "self", NULL
40101 };
40102
40103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40105 if (SWIG_arg_fail(1)) SWIG_fail;
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 result = (arg1)->GetMinSize();
40109
40110 wxPyEndAllowThreads(__tstate);
40111 if (PyErr_Occurred()) SWIG_fail;
40112 }
40113 {
40114 wxSize * resultptr;
40115 resultptr = new wxSize((wxSize &)(result));
40116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40117 }
40118 return resultobj;
40119 fail:
40120 return NULL;
40121 }
40122
40123
40124 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40125 PyObject *resultobj;
40126 wxSizer *arg1 = (wxSizer *) 0 ;
40127 PyObject * obj0 = 0 ;
40128 char *kwnames[] = {
40129 (char *) "self", NULL
40130 };
40131
40132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40134 if (SWIG_arg_fail(1)) SWIG_fail;
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 (arg1)->RecalcSizes();
40138
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 Py_INCREF(Py_None); resultobj = Py_None;
40143 return resultobj;
40144 fail:
40145 return NULL;
40146 }
40147
40148
40149 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40150 PyObject *resultobj;
40151 wxSizer *arg1 = (wxSizer *) 0 ;
40152 wxSize result;
40153 PyObject * obj0 = 0 ;
40154 char *kwnames[] = {
40155 (char *) "self", NULL
40156 };
40157
40158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40160 if (SWIG_arg_fail(1)) SWIG_fail;
40161 {
40162 PyThreadState* __tstate = wxPyBeginAllowThreads();
40163 result = (arg1)->CalcMin();
40164
40165 wxPyEndAllowThreads(__tstate);
40166 if (PyErr_Occurred()) SWIG_fail;
40167 }
40168 {
40169 wxSize * resultptr;
40170 resultptr = new wxSize((wxSize &)(result));
40171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40172 }
40173 return resultobj;
40174 fail:
40175 return NULL;
40176 }
40177
40178
40179 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40180 PyObject *resultobj;
40181 wxSizer *arg1 = (wxSizer *) 0 ;
40182 PyObject * obj0 = 0 ;
40183 char *kwnames[] = {
40184 (char *) "self", NULL
40185 };
40186
40187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40189 if (SWIG_arg_fail(1)) SWIG_fail;
40190 {
40191 PyThreadState* __tstate = wxPyBeginAllowThreads();
40192 (arg1)->Layout();
40193
40194 wxPyEndAllowThreads(__tstate);
40195 if (PyErr_Occurred()) SWIG_fail;
40196 }
40197 Py_INCREF(Py_None); resultobj = Py_None;
40198 return resultobj;
40199 fail:
40200 return NULL;
40201 }
40202
40203
40204 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40205 PyObject *resultobj;
40206 wxSizer *arg1 = (wxSizer *) 0 ;
40207 wxWindow *arg2 = (wxWindow *) 0 ;
40208 wxSize result;
40209 PyObject * obj0 = 0 ;
40210 PyObject * obj1 = 0 ;
40211 char *kwnames[] = {
40212 (char *) "self",(char *) "window", NULL
40213 };
40214
40215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40217 if (SWIG_arg_fail(1)) SWIG_fail;
40218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40219 if (SWIG_arg_fail(2)) SWIG_fail;
40220 {
40221 PyThreadState* __tstate = wxPyBeginAllowThreads();
40222 result = (arg1)->Fit(arg2);
40223
40224 wxPyEndAllowThreads(__tstate);
40225 if (PyErr_Occurred()) SWIG_fail;
40226 }
40227 {
40228 wxSize * resultptr;
40229 resultptr = new wxSize((wxSize &)(result));
40230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40231 }
40232 return resultobj;
40233 fail:
40234 return NULL;
40235 }
40236
40237
40238 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40239 PyObject *resultobj;
40240 wxSizer *arg1 = (wxSizer *) 0 ;
40241 wxWindow *arg2 = (wxWindow *) 0 ;
40242 PyObject * obj0 = 0 ;
40243 PyObject * obj1 = 0 ;
40244 char *kwnames[] = {
40245 (char *) "self",(char *) "window", NULL
40246 };
40247
40248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40250 if (SWIG_arg_fail(1)) SWIG_fail;
40251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40252 if (SWIG_arg_fail(2)) SWIG_fail;
40253 {
40254 PyThreadState* __tstate = wxPyBeginAllowThreads();
40255 (arg1)->FitInside(arg2);
40256
40257 wxPyEndAllowThreads(__tstate);
40258 if (PyErr_Occurred()) SWIG_fail;
40259 }
40260 Py_INCREF(Py_None); resultobj = Py_None;
40261 return resultobj;
40262 fail:
40263 return NULL;
40264 }
40265
40266
40267 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40268 PyObject *resultobj;
40269 wxSizer *arg1 = (wxSizer *) 0 ;
40270 wxWindow *arg2 = (wxWindow *) 0 ;
40271 PyObject * obj0 = 0 ;
40272 PyObject * obj1 = 0 ;
40273 char *kwnames[] = {
40274 (char *) "self",(char *) "window", NULL
40275 };
40276
40277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40279 if (SWIG_arg_fail(1)) SWIG_fail;
40280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40281 if (SWIG_arg_fail(2)) SWIG_fail;
40282 {
40283 PyThreadState* __tstate = wxPyBeginAllowThreads();
40284 (arg1)->SetSizeHints(arg2);
40285
40286 wxPyEndAllowThreads(__tstate);
40287 if (PyErr_Occurred()) SWIG_fail;
40288 }
40289 Py_INCREF(Py_None); resultobj = Py_None;
40290 return resultobj;
40291 fail:
40292 return NULL;
40293 }
40294
40295
40296 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40297 PyObject *resultobj;
40298 wxSizer *arg1 = (wxSizer *) 0 ;
40299 wxWindow *arg2 = (wxWindow *) 0 ;
40300 PyObject * obj0 = 0 ;
40301 PyObject * obj1 = 0 ;
40302 char *kwnames[] = {
40303 (char *) "self",(char *) "window", NULL
40304 };
40305
40306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40308 if (SWIG_arg_fail(1)) SWIG_fail;
40309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40310 if (SWIG_arg_fail(2)) SWIG_fail;
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 (arg1)->SetVirtualSizeHints(arg2);
40314
40315 wxPyEndAllowThreads(__tstate);
40316 if (PyErr_Occurred()) SWIG_fail;
40317 }
40318 Py_INCREF(Py_None); resultobj = Py_None;
40319 return resultobj;
40320 fail:
40321 return NULL;
40322 }
40323
40324
40325 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40326 PyObject *resultobj;
40327 wxSizer *arg1 = (wxSizer *) 0 ;
40328 bool arg2 = (bool) false ;
40329 PyObject * obj0 = 0 ;
40330 PyObject * obj1 = 0 ;
40331 char *kwnames[] = {
40332 (char *) "self",(char *) "deleteWindows", NULL
40333 };
40334
40335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40337 if (SWIG_arg_fail(1)) SWIG_fail;
40338 if (obj1) {
40339 {
40340 arg2 = (bool)(SWIG_As_bool(obj1));
40341 if (SWIG_arg_fail(2)) SWIG_fail;
40342 }
40343 }
40344 {
40345 PyThreadState* __tstate = wxPyBeginAllowThreads();
40346 (arg1)->Clear(arg2);
40347
40348 wxPyEndAllowThreads(__tstate);
40349 if (PyErr_Occurred()) SWIG_fail;
40350 }
40351 Py_INCREF(Py_None); resultobj = Py_None;
40352 return resultobj;
40353 fail:
40354 return NULL;
40355 }
40356
40357
40358 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40359 PyObject *resultobj;
40360 wxSizer *arg1 = (wxSizer *) 0 ;
40361 PyObject * obj0 = 0 ;
40362 char *kwnames[] = {
40363 (char *) "self", NULL
40364 };
40365
40366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40368 if (SWIG_arg_fail(1)) SWIG_fail;
40369 {
40370 PyThreadState* __tstate = wxPyBeginAllowThreads();
40371 (arg1)->DeleteWindows();
40372
40373 wxPyEndAllowThreads(__tstate);
40374 if (PyErr_Occurred()) SWIG_fail;
40375 }
40376 Py_INCREF(Py_None); resultobj = Py_None;
40377 return resultobj;
40378 fail:
40379 return NULL;
40380 }
40381
40382
40383 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40384 PyObject *resultobj;
40385 wxSizer *arg1 = (wxSizer *) 0 ;
40386 PyObject *result;
40387 PyObject * obj0 = 0 ;
40388 char *kwnames[] = {
40389 (char *) "self", NULL
40390 };
40391
40392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40394 if (SWIG_arg_fail(1)) SWIG_fail;
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 result = (PyObject *)wxSizer_GetChildren(arg1);
40398
40399 wxPyEndAllowThreads(__tstate);
40400 if (PyErr_Occurred()) SWIG_fail;
40401 }
40402 resultobj = result;
40403 return resultobj;
40404 fail:
40405 return NULL;
40406 }
40407
40408
40409 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj;
40411 wxSizer *arg1 = (wxSizer *) 0 ;
40412 PyObject *arg2 = (PyObject *) 0 ;
40413 bool arg3 = (bool) true ;
40414 bool arg4 = (bool) false ;
40415 bool result;
40416 PyObject * obj0 = 0 ;
40417 PyObject * obj1 = 0 ;
40418 PyObject * obj2 = 0 ;
40419 PyObject * obj3 = 0 ;
40420 char *kwnames[] = {
40421 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40422 };
40423
40424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40426 if (SWIG_arg_fail(1)) SWIG_fail;
40427 arg2 = obj1;
40428 if (obj2) {
40429 {
40430 arg3 = (bool)(SWIG_As_bool(obj2));
40431 if (SWIG_arg_fail(3)) SWIG_fail;
40432 }
40433 }
40434 if (obj3) {
40435 {
40436 arg4 = (bool)(SWIG_As_bool(obj3));
40437 if (SWIG_arg_fail(4)) SWIG_fail;
40438 }
40439 }
40440 {
40441 PyThreadState* __tstate = wxPyBeginAllowThreads();
40442 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40443
40444 wxPyEndAllowThreads(__tstate);
40445 if (PyErr_Occurred()) SWIG_fail;
40446 }
40447 {
40448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40449 }
40450 return resultobj;
40451 fail:
40452 return NULL;
40453 }
40454
40455
40456 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40457 PyObject *resultobj;
40458 wxSizer *arg1 = (wxSizer *) 0 ;
40459 PyObject *arg2 = (PyObject *) 0 ;
40460 bool result;
40461 PyObject * obj0 = 0 ;
40462 PyObject * obj1 = 0 ;
40463 char *kwnames[] = {
40464 (char *) "self",(char *) "item", NULL
40465 };
40466
40467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) 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 {
40472 PyThreadState* __tstate = wxPyBeginAllowThreads();
40473 result = (bool)wxSizer_IsShown(arg1,arg2);
40474
40475 wxPyEndAllowThreads(__tstate);
40476 if (PyErr_Occurred()) SWIG_fail;
40477 }
40478 {
40479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40480 }
40481 return resultobj;
40482 fail:
40483 return NULL;
40484 }
40485
40486
40487 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40488 PyObject *resultobj;
40489 wxSizer *arg1 = (wxSizer *) 0 ;
40490 bool arg2 ;
40491 PyObject * obj0 = 0 ;
40492 PyObject * obj1 = 0 ;
40493 char *kwnames[] = {
40494 (char *) "self",(char *) "show", NULL
40495 };
40496
40497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40499 if (SWIG_arg_fail(1)) SWIG_fail;
40500 {
40501 arg2 = (bool)(SWIG_As_bool(obj1));
40502 if (SWIG_arg_fail(2)) SWIG_fail;
40503 }
40504 {
40505 PyThreadState* __tstate = wxPyBeginAllowThreads();
40506 (arg1)->ShowItems(arg2);
40507
40508 wxPyEndAllowThreads(__tstate);
40509 if (PyErr_Occurred()) SWIG_fail;
40510 }
40511 Py_INCREF(Py_None); resultobj = Py_None;
40512 return resultobj;
40513 fail:
40514 return NULL;
40515 }
40516
40517
40518 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40519 PyObject *obj;
40520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40521 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40522 Py_INCREF(obj);
40523 return Py_BuildValue((char *)"");
40524 }
40525 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40526 PyObject *resultobj;
40527 wxPySizer *result;
40528 char *kwnames[] = {
40529 NULL
40530 };
40531
40532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40533 {
40534 PyThreadState* __tstate = wxPyBeginAllowThreads();
40535 result = (wxPySizer *)new wxPySizer();
40536
40537 wxPyEndAllowThreads(__tstate);
40538 if (PyErr_Occurred()) SWIG_fail;
40539 }
40540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40541 return resultobj;
40542 fail:
40543 return NULL;
40544 }
40545
40546
40547 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40548 PyObject *resultobj;
40549 wxPySizer *arg1 = (wxPySizer *) 0 ;
40550 PyObject *arg2 = (PyObject *) 0 ;
40551 PyObject *arg3 = (PyObject *) 0 ;
40552 PyObject * obj0 = 0 ;
40553 PyObject * obj1 = 0 ;
40554 PyObject * obj2 = 0 ;
40555 char *kwnames[] = {
40556 (char *) "self",(char *) "self",(char *) "_class", NULL
40557 };
40558
40559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40561 if (SWIG_arg_fail(1)) SWIG_fail;
40562 arg2 = obj1;
40563 arg3 = obj2;
40564 {
40565 PyThreadState* __tstate = wxPyBeginAllowThreads();
40566 (arg1)->_setCallbackInfo(arg2,arg3);
40567
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 Py_INCREF(Py_None); resultobj = Py_None;
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40579 PyObject *obj;
40580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40581 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40582 Py_INCREF(obj);
40583 return Py_BuildValue((char *)"");
40584 }
40585 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj;
40587 int arg1 = (int) wxHORIZONTAL ;
40588 wxBoxSizer *result;
40589 PyObject * obj0 = 0 ;
40590 char *kwnames[] = {
40591 (char *) "orient", NULL
40592 };
40593
40594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40595 if (obj0) {
40596 {
40597 arg1 = (int)(SWIG_As_int(obj0));
40598 if (SWIG_arg_fail(1)) SWIG_fail;
40599 }
40600 }
40601 {
40602 PyThreadState* __tstate = wxPyBeginAllowThreads();
40603 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40604
40605 wxPyEndAllowThreads(__tstate);
40606 if (PyErr_Occurred()) SWIG_fail;
40607 }
40608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40609 return resultobj;
40610 fail:
40611 return NULL;
40612 }
40613
40614
40615 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40616 PyObject *resultobj;
40617 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40618 int result;
40619 PyObject * obj0 = 0 ;
40620 char *kwnames[] = {
40621 (char *) "self", NULL
40622 };
40623
40624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40626 if (SWIG_arg_fail(1)) SWIG_fail;
40627 {
40628 PyThreadState* __tstate = wxPyBeginAllowThreads();
40629 result = (int)(arg1)->GetOrientation();
40630
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 {
40635 resultobj = SWIG_From_int((int)(result));
40636 }
40637 return resultobj;
40638 fail:
40639 return NULL;
40640 }
40641
40642
40643 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40644 PyObject *resultobj;
40645 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40646 int arg2 ;
40647 PyObject * obj0 = 0 ;
40648 PyObject * obj1 = 0 ;
40649 char *kwnames[] = {
40650 (char *) "self",(char *) "orient", NULL
40651 };
40652
40653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40655 if (SWIG_arg_fail(1)) SWIG_fail;
40656 {
40657 arg2 = (int)(SWIG_As_int(obj1));
40658 if (SWIG_arg_fail(2)) SWIG_fail;
40659 }
40660 {
40661 PyThreadState* __tstate = wxPyBeginAllowThreads();
40662 (arg1)->SetOrientation(arg2);
40663
40664 wxPyEndAllowThreads(__tstate);
40665 if (PyErr_Occurred()) SWIG_fail;
40666 }
40667 Py_INCREF(Py_None); resultobj = Py_None;
40668 return resultobj;
40669 fail:
40670 return NULL;
40671 }
40672
40673
40674 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40675 PyObject *obj;
40676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40677 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40678 Py_INCREF(obj);
40679 return Py_BuildValue((char *)"");
40680 }
40681 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40682 PyObject *resultobj;
40683 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40684 int arg2 = (int) wxHORIZONTAL ;
40685 wxStaticBoxSizer *result;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 char *kwnames[] = {
40689 (char *) "box",(char *) "orient", NULL
40690 };
40691
40692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40694 if (SWIG_arg_fail(1)) SWIG_fail;
40695 if (obj1) {
40696 {
40697 arg2 = (int)(SWIG_As_int(obj1));
40698 if (SWIG_arg_fail(2)) SWIG_fail;
40699 }
40700 }
40701 {
40702 PyThreadState* __tstate = wxPyBeginAllowThreads();
40703 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40704
40705 wxPyEndAllowThreads(__tstate);
40706 if (PyErr_Occurred()) SWIG_fail;
40707 }
40708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40709 return resultobj;
40710 fail:
40711 return NULL;
40712 }
40713
40714
40715 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40716 PyObject *resultobj;
40717 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40718 wxStaticBox *result;
40719 PyObject * obj0 = 0 ;
40720 char *kwnames[] = {
40721 (char *) "self", NULL
40722 };
40723
40724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40726 if (SWIG_arg_fail(1)) SWIG_fail;
40727 {
40728 PyThreadState* __tstate = wxPyBeginAllowThreads();
40729 result = (wxStaticBox *)(arg1)->GetStaticBox();
40730
40731 wxPyEndAllowThreads(__tstate);
40732 if (PyErr_Occurred()) SWIG_fail;
40733 }
40734 {
40735 resultobj = wxPyMake_wxObject(result, 0);
40736 }
40737 return resultobj;
40738 fail:
40739 return NULL;
40740 }
40741
40742
40743 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40744 PyObject *obj;
40745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40746 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40747 Py_INCREF(obj);
40748 return Py_BuildValue((char *)"");
40749 }
40750 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40751 PyObject *resultobj;
40752 int arg1 = (int) 1 ;
40753 int arg2 = (int) 0 ;
40754 int arg3 = (int) 0 ;
40755 int arg4 = (int) 0 ;
40756 wxGridSizer *result;
40757 PyObject * obj0 = 0 ;
40758 PyObject * obj1 = 0 ;
40759 PyObject * obj2 = 0 ;
40760 PyObject * obj3 = 0 ;
40761 char *kwnames[] = {
40762 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40763 };
40764
40765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40766 if (obj0) {
40767 {
40768 arg1 = (int)(SWIG_As_int(obj0));
40769 if (SWIG_arg_fail(1)) SWIG_fail;
40770 }
40771 }
40772 if (obj1) {
40773 {
40774 arg2 = (int)(SWIG_As_int(obj1));
40775 if (SWIG_arg_fail(2)) SWIG_fail;
40776 }
40777 }
40778 if (obj2) {
40779 {
40780 arg3 = (int)(SWIG_As_int(obj2));
40781 if (SWIG_arg_fail(3)) SWIG_fail;
40782 }
40783 }
40784 if (obj3) {
40785 {
40786 arg4 = (int)(SWIG_As_int(obj3));
40787 if (SWIG_arg_fail(4)) SWIG_fail;
40788 }
40789 }
40790 {
40791 PyThreadState* __tstate = wxPyBeginAllowThreads();
40792 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40793
40794 wxPyEndAllowThreads(__tstate);
40795 if (PyErr_Occurred()) SWIG_fail;
40796 }
40797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40798 return resultobj;
40799 fail:
40800 return NULL;
40801 }
40802
40803
40804 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40805 PyObject *resultobj;
40806 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40807 int arg2 ;
40808 PyObject * obj0 = 0 ;
40809 PyObject * obj1 = 0 ;
40810 char *kwnames[] = {
40811 (char *) "self",(char *) "cols", NULL
40812 };
40813
40814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40816 if (SWIG_arg_fail(1)) SWIG_fail;
40817 {
40818 arg2 = (int)(SWIG_As_int(obj1));
40819 if (SWIG_arg_fail(2)) SWIG_fail;
40820 }
40821 {
40822 PyThreadState* __tstate = wxPyBeginAllowThreads();
40823 (arg1)->SetCols(arg2);
40824
40825 wxPyEndAllowThreads(__tstate);
40826 if (PyErr_Occurred()) SWIG_fail;
40827 }
40828 Py_INCREF(Py_None); resultobj = Py_None;
40829 return resultobj;
40830 fail:
40831 return NULL;
40832 }
40833
40834
40835 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40836 PyObject *resultobj;
40837 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40838 int arg2 ;
40839 PyObject * obj0 = 0 ;
40840 PyObject * obj1 = 0 ;
40841 char *kwnames[] = {
40842 (char *) "self",(char *) "rows", NULL
40843 };
40844
40845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40847 if (SWIG_arg_fail(1)) SWIG_fail;
40848 {
40849 arg2 = (int)(SWIG_As_int(obj1));
40850 if (SWIG_arg_fail(2)) SWIG_fail;
40851 }
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 (arg1)->SetRows(arg2);
40855
40856 wxPyEndAllowThreads(__tstate);
40857 if (PyErr_Occurred()) SWIG_fail;
40858 }
40859 Py_INCREF(Py_None); resultobj = Py_None;
40860 return resultobj;
40861 fail:
40862 return NULL;
40863 }
40864
40865
40866 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40867 PyObject *resultobj;
40868 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40869 int arg2 ;
40870 PyObject * obj0 = 0 ;
40871 PyObject * obj1 = 0 ;
40872 char *kwnames[] = {
40873 (char *) "self",(char *) "gap", NULL
40874 };
40875
40876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40878 if (SWIG_arg_fail(1)) SWIG_fail;
40879 {
40880 arg2 = (int)(SWIG_As_int(obj1));
40881 if (SWIG_arg_fail(2)) SWIG_fail;
40882 }
40883 {
40884 PyThreadState* __tstate = wxPyBeginAllowThreads();
40885 (arg1)->SetVGap(arg2);
40886
40887 wxPyEndAllowThreads(__tstate);
40888 if (PyErr_Occurred()) SWIG_fail;
40889 }
40890 Py_INCREF(Py_None); resultobj = Py_None;
40891 return resultobj;
40892 fail:
40893 return NULL;
40894 }
40895
40896
40897 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40898 PyObject *resultobj;
40899 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40900 int arg2 ;
40901 PyObject * obj0 = 0 ;
40902 PyObject * obj1 = 0 ;
40903 char *kwnames[] = {
40904 (char *) "self",(char *) "gap", NULL
40905 };
40906
40907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40909 if (SWIG_arg_fail(1)) SWIG_fail;
40910 {
40911 arg2 = (int)(SWIG_As_int(obj1));
40912 if (SWIG_arg_fail(2)) SWIG_fail;
40913 }
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 (arg1)->SetHGap(arg2);
40917
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 Py_INCREF(Py_None); resultobj = Py_None;
40922 return resultobj;
40923 fail:
40924 return NULL;
40925 }
40926
40927
40928 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40929 PyObject *resultobj;
40930 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40931 int result;
40932 PyObject * obj0 = 0 ;
40933 char *kwnames[] = {
40934 (char *) "self", NULL
40935 };
40936
40937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40939 if (SWIG_arg_fail(1)) SWIG_fail;
40940 {
40941 PyThreadState* __tstate = wxPyBeginAllowThreads();
40942 result = (int)(arg1)->GetCols();
40943
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 {
40948 resultobj = SWIG_From_int((int)(result));
40949 }
40950 return resultobj;
40951 fail:
40952 return NULL;
40953 }
40954
40955
40956 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40957 PyObject *resultobj;
40958 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40959 int result;
40960 PyObject * obj0 = 0 ;
40961 char *kwnames[] = {
40962 (char *) "self", NULL
40963 };
40964
40965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40967 if (SWIG_arg_fail(1)) SWIG_fail;
40968 {
40969 PyThreadState* __tstate = wxPyBeginAllowThreads();
40970 result = (int)(arg1)->GetRows();
40971
40972 wxPyEndAllowThreads(__tstate);
40973 if (PyErr_Occurred()) SWIG_fail;
40974 }
40975 {
40976 resultobj = SWIG_From_int((int)(result));
40977 }
40978 return resultobj;
40979 fail:
40980 return NULL;
40981 }
40982
40983
40984 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40985 PyObject *resultobj;
40986 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40987 int result;
40988 PyObject * obj0 = 0 ;
40989 char *kwnames[] = {
40990 (char *) "self", NULL
40991 };
40992
40993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40995 if (SWIG_arg_fail(1)) SWIG_fail;
40996 {
40997 PyThreadState* __tstate = wxPyBeginAllowThreads();
40998 result = (int)(arg1)->GetVGap();
40999
41000 wxPyEndAllowThreads(__tstate);
41001 if (PyErr_Occurred()) SWIG_fail;
41002 }
41003 {
41004 resultobj = SWIG_From_int((int)(result));
41005 }
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41013 PyObject *resultobj;
41014 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41015 int result;
41016 PyObject * obj0 = 0 ;
41017 char *kwnames[] = {
41018 (char *) "self", NULL
41019 };
41020
41021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41023 if (SWIG_arg_fail(1)) SWIG_fail;
41024 {
41025 PyThreadState* __tstate = wxPyBeginAllowThreads();
41026 result = (int)(arg1)->GetHGap();
41027
41028 wxPyEndAllowThreads(__tstate);
41029 if (PyErr_Occurred()) SWIG_fail;
41030 }
41031 {
41032 resultobj = SWIG_From_int((int)(result));
41033 }
41034 return resultobj;
41035 fail:
41036 return NULL;
41037 }
41038
41039
41040 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41041 PyObject *obj;
41042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41043 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41044 Py_INCREF(obj);
41045 return Py_BuildValue((char *)"");
41046 }
41047 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41048 PyObject *resultobj;
41049 int arg1 = (int) 1 ;
41050 int arg2 = (int) 0 ;
41051 int arg3 = (int) 0 ;
41052 int arg4 = (int) 0 ;
41053 wxFlexGridSizer *result;
41054 PyObject * obj0 = 0 ;
41055 PyObject * obj1 = 0 ;
41056 PyObject * obj2 = 0 ;
41057 PyObject * obj3 = 0 ;
41058 char *kwnames[] = {
41059 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41060 };
41061
41062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41063 if (obj0) {
41064 {
41065 arg1 = (int)(SWIG_As_int(obj0));
41066 if (SWIG_arg_fail(1)) SWIG_fail;
41067 }
41068 }
41069 if (obj1) {
41070 {
41071 arg2 = (int)(SWIG_As_int(obj1));
41072 if (SWIG_arg_fail(2)) SWIG_fail;
41073 }
41074 }
41075 if (obj2) {
41076 {
41077 arg3 = (int)(SWIG_As_int(obj2));
41078 if (SWIG_arg_fail(3)) SWIG_fail;
41079 }
41080 }
41081 if (obj3) {
41082 {
41083 arg4 = (int)(SWIG_As_int(obj3));
41084 if (SWIG_arg_fail(4)) SWIG_fail;
41085 }
41086 }
41087 {
41088 PyThreadState* __tstate = wxPyBeginAllowThreads();
41089 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41090
41091 wxPyEndAllowThreads(__tstate);
41092 if (PyErr_Occurred()) SWIG_fail;
41093 }
41094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41095 return resultobj;
41096 fail:
41097 return NULL;
41098 }
41099
41100
41101 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41102 PyObject *resultobj;
41103 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41104 size_t arg2 ;
41105 int arg3 = (int) 0 ;
41106 PyObject * obj0 = 0 ;
41107 PyObject * obj1 = 0 ;
41108 PyObject * obj2 = 0 ;
41109 char *kwnames[] = {
41110 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41111 };
41112
41113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41115 if (SWIG_arg_fail(1)) SWIG_fail;
41116 {
41117 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41118 if (SWIG_arg_fail(2)) SWIG_fail;
41119 }
41120 if (obj2) {
41121 {
41122 arg3 = (int)(SWIG_As_int(obj2));
41123 if (SWIG_arg_fail(3)) SWIG_fail;
41124 }
41125 }
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 (arg1)->AddGrowableRow(arg2,arg3);
41129
41130 wxPyEndAllowThreads(__tstate);
41131 if (PyErr_Occurred()) SWIG_fail;
41132 }
41133 Py_INCREF(Py_None); resultobj = Py_None;
41134 return resultobj;
41135 fail:
41136 return NULL;
41137 }
41138
41139
41140 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj;
41142 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41143 size_t arg2 ;
41144 PyObject * obj0 = 0 ;
41145 PyObject * obj1 = 0 ;
41146 char *kwnames[] = {
41147 (char *) "self",(char *) "idx", NULL
41148 };
41149
41150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41152 if (SWIG_arg_fail(1)) SWIG_fail;
41153 {
41154 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41155 if (SWIG_arg_fail(2)) SWIG_fail;
41156 }
41157 {
41158 PyThreadState* __tstate = wxPyBeginAllowThreads();
41159 (arg1)->RemoveGrowableRow(arg2);
41160
41161 wxPyEndAllowThreads(__tstate);
41162 if (PyErr_Occurred()) SWIG_fail;
41163 }
41164 Py_INCREF(Py_None); resultobj = Py_None;
41165 return resultobj;
41166 fail:
41167 return NULL;
41168 }
41169
41170
41171 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41172 PyObject *resultobj;
41173 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41174 size_t arg2 ;
41175 int arg3 = (int) 0 ;
41176 PyObject * obj0 = 0 ;
41177 PyObject * obj1 = 0 ;
41178 PyObject * obj2 = 0 ;
41179 char *kwnames[] = {
41180 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41181 };
41182
41183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41185 if (SWIG_arg_fail(1)) SWIG_fail;
41186 {
41187 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41188 if (SWIG_arg_fail(2)) SWIG_fail;
41189 }
41190 if (obj2) {
41191 {
41192 arg3 = (int)(SWIG_As_int(obj2));
41193 if (SWIG_arg_fail(3)) SWIG_fail;
41194 }
41195 }
41196 {
41197 PyThreadState* __tstate = wxPyBeginAllowThreads();
41198 (arg1)->AddGrowableCol(arg2,arg3);
41199
41200 wxPyEndAllowThreads(__tstate);
41201 if (PyErr_Occurred()) SWIG_fail;
41202 }
41203 Py_INCREF(Py_None); resultobj = Py_None;
41204 return resultobj;
41205 fail:
41206 return NULL;
41207 }
41208
41209
41210 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41211 PyObject *resultobj;
41212 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41213 size_t arg2 ;
41214 PyObject * obj0 = 0 ;
41215 PyObject * obj1 = 0 ;
41216 char *kwnames[] = {
41217 (char *) "self",(char *) "idx", NULL
41218 };
41219
41220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41222 if (SWIG_arg_fail(1)) SWIG_fail;
41223 {
41224 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41225 if (SWIG_arg_fail(2)) SWIG_fail;
41226 }
41227 {
41228 PyThreadState* __tstate = wxPyBeginAllowThreads();
41229 (arg1)->RemoveGrowableCol(arg2);
41230
41231 wxPyEndAllowThreads(__tstate);
41232 if (PyErr_Occurred()) SWIG_fail;
41233 }
41234 Py_INCREF(Py_None); resultobj = Py_None;
41235 return resultobj;
41236 fail:
41237 return NULL;
41238 }
41239
41240
41241 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41242 PyObject *resultobj;
41243 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41244 int arg2 ;
41245 PyObject * obj0 = 0 ;
41246 PyObject * obj1 = 0 ;
41247 char *kwnames[] = {
41248 (char *) "self",(char *) "direction", NULL
41249 };
41250
41251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41253 if (SWIG_arg_fail(1)) SWIG_fail;
41254 {
41255 arg2 = (int)(SWIG_As_int(obj1));
41256 if (SWIG_arg_fail(2)) SWIG_fail;
41257 }
41258 {
41259 PyThreadState* __tstate = wxPyBeginAllowThreads();
41260 (arg1)->SetFlexibleDirection(arg2);
41261
41262 wxPyEndAllowThreads(__tstate);
41263 if (PyErr_Occurred()) SWIG_fail;
41264 }
41265 Py_INCREF(Py_None); resultobj = Py_None;
41266 return resultobj;
41267 fail:
41268 return NULL;
41269 }
41270
41271
41272 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41273 PyObject *resultobj;
41274 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41275 int result;
41276 PyObject * obj0 = 0 ;
41277 char *kwnames[] = {
41278 (char *) "self", NULL
41279 };
41280
41281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41283 if (SWIG_arg_fail(1)) SWIG_fail;
41284 {
41285 PyThreadState* __tstate = wxPyBeginAllowThreads();
41286 result = (int)(arg1)->GetFlexibleDirection();
41287
41288 wxPyEndAllowThreads(__tstate);
41289 if (PyErr_Occurred()) SWIG_fail;
41290 }
41291 {
41292 resultobj = SWIG_From_int((int)(result));
41293 }
41294 return resultobj;
41295 fail:
41296 return NULL;
41297 }
41298
41299
41300 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41301 PyObject *resultobj;
41302 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41303 wxFlexSizerGrowMode arg2 ;
41304 PyObject * obj0 = 0 ;
41305 PyObject * obj1 = 0 ;
41306 char *kwnames[] = {
41307 (char *) "self",(char *) "mode", NULL
41308 };
41309
41310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41312 if (SWIG_arg_fail(1)) SWIG_fail;
41313 {
41314 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41315 if (SWIG_arg_fail(2)) SWIG_fail;
41316 }
41317 {
41318 PyThreadState* __tstate = wxPyBeginAllowThreads();
41319 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41320
41321 wxPyEndAllowThreads(__tstate);
41322 if (PyErr_Occurred()) SWIG_fail;
41323 }
41324 Py_INCREF(Py_None); resultobj = Py_None;
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41332 PyObject *resultobj;
41333 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41334 wxFlexSizerGrowMode result;
41335 PyObject * obj0 = 0 ;
41336 char *kwnames[] = {
41337 (char *) "self", NULL
41338 };
41339
41340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41342 if (SWIG_arg_fail(1)) SWIG_fail;
41343 {
41344 PyThreadState* __tstate = wxPyBeginAllowThreads();
41345 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41346
41347 wxPyEndAllowThreads(__tstate);
41348 if (PyErr_Occurred()) SWIG_fail;
41349 }
41350 resultobj = SWIG_From_int((result));
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj;
41359 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41360 wxArrayInt *result;
41361 PyObject * obj0 = 0 ;
41362 char *kwnames[] = {
41363 (char *) "self", NULL
41364 };
41365
41366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41368 if (SWIG_arg_fail(1)) SWIG_fail;
41369 {
41370 PyThreadState* __tstate = wxPyBeginAllowThreads();
41371 {
41372 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41373 result = (wxArrayInt *) &_result_ref;
41374 }
41375
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 {
41380 resultobj = PyList_New(0);
41381 size_t idx;
41382 for (idx = 0; idx < result->GetCount(); idx += 1) {
41383 PyObject* val = PyInt_FromLong( result->Item(idx) );
41384 PyList_Append(resultobj, val);
41385 Py_DECREF(val);
41386 }
41387 }
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj;
41396 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41397 wxArrayInt *result;
41398 PyObject * obj0 = 0 ;
41399 char *kwnames[] = {
41400 (char *) "self", NULL
41401 };
41402
41403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41405 if (SWIG_arg_fail(1)) SWIG_fail;
41406 {
41407 PyThreadState* __tstate = wxPyBeginAllowThreads();
41408 {
41409 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41410 result = (wxArrayInt *) &_result_ref;
41411 }
41412
41413 wxPyEndAllowThreads(__tstate);
41414 if (PyErr_Occurred()) SWIG_fail;
41415 }
41416 {
41417 resultobj = PyList_New(0);
41418 size_t idx;
41419 for (idx = 0; idx < result->GetCount(); idx += 1) {
41420 PyObject* val = PyInt_FromLong( result->Item(idx) );
41421 PyList_Append(resultobj, val);
41422 Py_DECREF(val);
41423 }
41424 }
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41432 PyObject *obj;
41433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41434 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41435 Py_INCREF(obj);
41436 return Py_BuildValue((char *)"");
41437 }
41438 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41439 PyObject *resultobj;
41440 wxStdDialogButtonSizer *result;
41441 char *kwnames[] = {
41442 NULL
41443 };
41444
41445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41446 {
41447 PyThreadState* __tstate = wxPyBeginAllowThreads();
41448 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41449
41450 wxPyEndAllowThreads(__tstate);
41451 if (PyErr_Occurred()) SWIG_fail;
41452 }
41453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41454 return resultobj;
41455 fail:
41456 return NULL;
41457 }
41458
41459
41460 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41461 PyObject *resultobj;
41462 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41463 wxButton *arg2 = (wxButton *) 0 ;
41464 PyObject * obj0 = 0 ;
41465 PyObject * obj1 = 0 ;
41466 char *kwnames[] = {
41467 (char *) "self",(char *) "button", NULL
41468 };
41469
41470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41472 if (SWIG_arg_fail(1)) SWIG_fail;
41473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41474 if (SWIG_arg_fail(2)) SWIG_fail;
41475 {
41476 PyThreadState* __tstate = wxPyBeginAllowThreads();
41477 (arg1)->AddButton(arg2);
41478
41479 wxPyEndAllowThreads(__tstate);
41480 if (PyErr_Occurred()) SWIG_fail;
41481 }
41482 Py_INCREF(Py_None); resultobj = Py_None;
41483 return resultobj;
41484 fail:
41485 return NULL;
41486 }
41487
41488
41489 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj;
41491 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41492 PyObject * obj0 = 0 ;
41493 char *kwnames[] = {
41494 (char *) "self", NULL
41495 };
41496
41497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41499 if (SWIG_arg_fail(1)) SWIG_fail;
41500 {
41501 PyThreadState* __tstate = wxPyBeginAllowThreads();
41502 (arg1)->Realize();
41503
41504 wxPyEndAllowThreads(__tstate);
41505 if (PyErr_Occurred()) SWIG_fail;
41506 }
41507 Py_INCREF(Py_None); resultobj = Py_None;
41508 return resultobj;
41509 fail:
41510 return NULL;
41511 }
41512
41513
41514 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41515 PyObject *resultobj;
41516 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41517 wxButton *arg2 = (wxButton *) 0 ;
41518 PyObject * obj0 = 0 ;
41519 PyObject * obj1 = 0 ;
41520 char *kwnames[] = {
41521 (char *) "self",(char *) "button", NULL
41522 };
41523
41524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41526 if (SWIG_arg_fail(1)) SWIG_fail;
41527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41528 if (SWIG_arg_fail(2)) SWIG_fail;
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 (arg1)->SetAffirmativeButton(arg2);
41532
41533 wxPyEndAllowThreads(__tstate);
41534 if (PyErr_Occurred()) SWIG_fail;
41535 }
41536 Py_INCREF(Py_None); resultobj = Py_None;
41537 return resultobj;
41538 fail:
41539 return NULL;
41540 }
41541
41542
41543 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41544 PyObject *resultobj;
41545 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41546 wxButton *arg2 = (wxButton *) 0 ;
41547 PyObject * obj0 = 0 ;
41548 PyObject * obj1 = 0 ;
41549 char *kwnames[] = {
41550 (char *) "self",(char *) "button", NULL
41551 };
41552
41553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41555 if (SWIG_arg_fail(1)) SWIG_fail;
41556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41557 if (SWIG_arg_fail(2)) SWIG_fail;
41558 {
41559 PyThreadState* __tstate = wxPyBeginAllowThreads();
41560 (arg1)->SetNegativeButton(arg2);
41561
41562 wxPyEndAllowThreads(__tstate);
41563 if (PyErr_Occurred()) SWIG_fail;
41564 }
41565 Py_INCREF(Py_None); resultobj = Py_None;
41566 return resultobj;
41567 fail:
41568 return NULL;
41569 }
41570
41571
41572 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41573 PyObject *resultobj;
41574 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41575 wxButton *arg2 = (wxButton *) 0 ;
41576 PyObject * obj0 = 0 ;
41577 PyObject * obj1 = 0 ;
41578 char *kwnames[] = {
41579 (char *) "self",(char *) "button", NULL
41580 };
41581
41582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41584 if (SWIG_arg_fail(1)) SWIG_fail;
41585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41586 if (SWIG_arg_fail(2)) SWIG_fail;
41587 {
41588 PyThreadState* __tstate = wxPyBeginAllowThreads();
41589 (arg1)->SetCancelButton(arg2);
41590
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 Py_INCREF(Py_None); resultobj = Py_None;
41595 return resultobj;
41596 fail:
41597 return NULL;
41598 }
41599
41600
41601 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41602 PyObject *resultobj;
41603 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41604 wxButton *result;
41605 PyObject * obj0 = 0 ;
41606 char *kwnames[] = {
41607 (char *) "self", NULL
41608 };
41609
41610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41612 if (SWIG_arg_fail(1)) SWIG_fail;
41613 {
41614 PyThreadState* __tstate = wxPyBeginAllowThreads();
41615 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41616
41617 wxPyEndAllowThreads(__tstate);
41618 if (PyErr_Occurred()) SWIG_fail;
41619 }
41620 {
41621 resultobj = wxPyMake_wxObject(result, 0);
41622 }
41623 return resultobj;
41624 fail:
41625 return NULL;
41626 }
41627
41628
41629 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41630 PyObject *resultobj;
41631 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41632 wxButton *result;
41633 PyObject * obj0 = 0 ;
41634 char *kwnames[] = {
41635 (char *) "self", NULL
41636 };
41637
41638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41640 if (SWIG_arg_fail(1)) SWIG_fail;
41641 {
41642 PyThreadState* __tstate = wxPyBeginAllowThreads();
41643 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41644
41645 wxPyEndAllowThreads(__tstate);
41646 if (PyErr_Occurred()) SWIG_fail;
41647 }
41648 {
41649 resultobj = wxPyMake_wxObject(result, 0);
41650 }
41651 return resultobj;
41652 fail:
41653 return NULL;
41654 }
41655
41656
41657 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41658 PyObject *resultobj;
41659 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41660 wxButton *result;
41661 PyObject * obj0 = 0 ;
41662 char *kwnames[] = {
41663 (char *) "self", NULL
41664 };
41665
41666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41668 if (SWIG_arg_fail(1)) SWIG_fail;
41669 {
41670 PyThreadState* __tstate = wxPyBeginAllowThreads();
41671 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41672
41673 wxPyEndAllowThreads(__tstate);
41674 if (PyErr_Occurred()) SWIG_fail;
41675 }
41676 {
41677 resultobj = wxPyMake_wxObject(result, 0);
41678 }
41679 return resultobj;
41680 fail:
41681 return NULL;
41682 }
41683
41684
41685 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41686 PyObject *resultobj;
41687 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41688 wxButton *result;
41689 PyObject * obj0 = 0 ;
41690 char *kwnames[] = {
41691 (char *) "self", NULL
41692 };
41693
41694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41696 if (SWIG_arg_fail(1)) SWIG_fail;
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41700
41701 wxPyEndAllowThreads(__tstate);
41702 if (PyErr_Occurred()) SWIG_fail;
41703 }
41704 {
41705 resultobj = wxPyMake_wxObject(result, 0);
41706 }
41707 return resultobj;
41708 fail:
41709 return NULL;
41710 }
41711
41712
41713 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41714 PyObject *resultobj;
41715 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41716 wxButton *result;
41717 PyObject * obj0 = 0 ;
41718 char *kwnames[] = {
41719 (char *) "self", NULL
41720 };
41721
41722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41724 if (SWIG_arg_fail(1)) SWIG_fail;
41725 {
41726 PyThreadState* __tstate = wxPyBeginAllowThreads();
41727 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41728
41729 wxPyEndAllowThreads(__tstate);
41730 if (PyErr_Occurred()) SWIG_fail;
41731 }
41732 {
41733 resultobj = wxPyMake_wxObject(result, 0);
41734 }
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41742 PyObject *obj;
41743 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41744 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41745 Py_INCREF(obj);
41746 return Py_BuildValue((char *)"");
41747 }
41748 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41749 PyObject *resultobj;
41750 int arg1 = (int) 0 ;
41751 int arg2 = (int) 0 ;
41752 wxGBPosition *result;
41753 PyObject * obj0 = 0 ;
41754 PyObject * obj1 = 0 ;
41755 char *kwnames[] = {
41756 (char *) "row",(char *) "col", NULL
41757 };
41758
41759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41760 if (obj0) {
41761 {
41762 arg1 = (int)(SWIG_As_int(obj0));
41763 if (SWIG_arg_fail(1)) SWIG_fail;
41764 }
41765 }
41766 if (obj1) {
41767 {
41768 arg2 = (int)(SWIG_As_int(obj1));
41769 if (SWIG_arg_fail(2)) SWIG_fail;
41770 }
41771 }
41772 {
41773 PyThreadState* __tstate = wxPyBeginAllowThreads();
41774 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41775
41776 wxPyEndAllowThreads(__tstate);
41777 if (PyErr_Occurred()) SWIG_fail;
41778 }
41779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41780 return resultobj;
41781 fail:
41782 return NULL;
41783 }
41784
41785
41786 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41787 PyObject *resultobj;
41788 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41789 int result;
41790 PyObject * obj0 = 0 ;
41791 char *kwnames[] = {
41792 (char *) "self", NULL
41793 };
41794
41795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41797 if (SWIG_arg_fail(1)) SWIG_fail;
41798 {
41799 PyThreadState* __tstate = wxPyBeginAllowThreads();
41800 result = (int)((wxGBPosition const *)arg1)->GetRow();
41801
41802 wxPyEndAllowThreads(__tstate);
41803 if (PyErr_Occurred()) SWIG_fail;
41804 }
41805 {
41806 resultobj = SWIG_From_int((int)(result));
41807 }
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj;
41816 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41817 int result;
41818 PyObject * obj0 = 0 ;
41819 char *kwnames[] = {
41820 (char *) "self", NULL
41821 };
41822
41823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41825 if (SWIG_arg_fail(1)) SWIG_fail;
41826 {
41827 PyThreadState* __tstate = wxPyBeginAllowThreads();
41828 result = (int)((wxGBPosition const *)arg1)->GetCol();
41829
41830 wxPyEndAllowThreads(__tstate);
41831 if (PyErr_Occurred()) SWIG_fail;
41832 }
41833 {
41834 resultobj = SWIG_From_int((int)(result));
41835 }
41836 return resultobj;
41837 fail:
41838 return NULL;
41839 }
41840
41841
41842 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41843 PyObject *resultobj;
41844 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41845 int arg2 ;
41846 PyObject * obj0 = 0 ;
41847 PyObject * obj1 = 0 ;
41848 char *kwnames[] = {
41849 (char *) "self",(char *) "row", NULL
41850 };
41851
41852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41854 if (SWIG_arg_fail(1)) SWIG_fail;
41855 {
41856 arg2 = (int)(SWIG_As_int(obj1));
41857 if (SWIG_arg_fail(2)) SWIG_fail;
41858 }
41859 {
41860 PyThreadState* __tstate = wxPyBeginAllowThreads();
41861 (arg1)->SetRow(arg2);
41862
41863 wxPyEndAllowThreads(__tstate);
41864 if (PyErr_Occurred()) SWIG_fail;
41865 }
41866 Py_INCREF(Py_None); resultobj = Py_None;
41867 return resultobj;
41868 fail:
41869 return NULL;
41870 }
41871
41872
41873 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41874 PyObject *resultobj;
41875 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41876 int arg2 ;
41877 PyObject * obj0 = 0 ;
41878 PyObject * obj1 = 0 ;
41879 char *kwnames[] = {
41880 (char *) "self",(char *) "col", NULL
41881 };
41882
41883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41885 if (SWIG_arg_fail(1)) SWIG_fail;
41886 {
41887 arg2 = (int)(SWIG_As_int(obj1));
41888 if (SWIG_arg_fail(2)) SWIG_fail;
41889 }
41890 {
41891 PyThreadState* __tstate = wxPyBeginAllowThreads();
41892 (arg1)->SetCol(arg2);
41893
41894 wxPyEndAllowThreads(__tstate);
41895 if (PyErr_Occurred()) SWIG_fail;
41896 }
41897 Py_INCREF(Py_None); resultobj = Py_None;
41898 return resultobj;
41899 fail:
41900 return NULL;
41901 }
41902
41903
41904 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41905 PyObject *resultobj;
41906 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41907 wxGBPosition *arg2 = 0 ;
41908 bool result;
41909 wxGBPosition temp2 ;
41910 PyObject * obj0 = 0 ;
41911 PyObject * obj1 = 0 ;
41912 char *kwnames[] = {
41913 (char *) "self",(char *) "other", NULL
41914 };
41915
41916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41918 if (SWIG_arg_fail(1)) SWIG_fail;
41919 {
41920 arg2 = &temp2;
41921 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41922 }
41923 {
41924 PyThreadState* __tstate = wxPyBeginAllowThreads();
41925 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41926
41927 wxPyEndAllowThreads(__tstate);
41928 if (PyErr_Occurred()) SWIG_fail;
41929 }
41930 {
41931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41932 }
41933 return resultobj;
41934 fail:
41935 return NULL;
41936 }
41937
41938
41939 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41940 PyObject *resultobj;
41941 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41942 wxGBPosition *arg2 = 0 ;
41943 bool result;
41944 wxGBPosition temp2 ;
41945 PyObject * obj0 = 0 ;
41946 PyObject * obj1 = 0 ;
41947 char *kwnames[] = {
41948 (char *) "self",(char *) "other", NULL
41949 };
41950
41951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41953 if (SWIG_arg_fail(1)) SWIG_fail;
41954 {
41955 arg2 = &temp2;
41956 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41957 }
41958 {
41959 PyThreadState* __tstate = wxPyBeginAllowThreads();
41960 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41961
41962 wxPyEndAllowThreads(__tstate);
41963 if (PyErr_Occurred()) SWIG_fail;
41964 }
41965 {
41966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41967 }
41968 return resultobj;
41969 fail:
41970 return NULL;
41971 }
41972
41973
41974 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41975 PyObject *resultobj;
41976 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41977 int arg2 = (int) 0 ;
41978 int arg3 = (int) 0 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 PyObject * obj2 = 0 ;
41982 char *kwnames[] = {
41983 (char *) "self",(char *) "row",(char *) "col", NULL
41984 };
41985
41986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41988 if (SWIG_arg_fail(1)) SWIG_fail;
41989 if (obj1) {
41990 {
41991 arg2 = (int)(SWIG_As_int(obj1));
41992 if (SWIG_arg_fail(2)) SWIG_fail;
41993 }
41994 }
41995 if (obj2) {
41996 {
41997 arg3 = (int)(SWIG_As_int(obj2));
41998 if (SWIG_arg_fail(3)) SWIG_fail;
41999 }
42000 }
42001 {
42002 PyThreadState* __tstate = wxPyBeginAllowThreads();
42003 wxGBPosition_Set(arg1,arg2,arg3);
42004
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 Py_INCREF(Py_None); resultobj = Py_None;
42009 return resultobj;
42010 fail:
42011 return NULL;
42012 }
42013
42014
42015 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42016 PyObject *resultobj;
42017 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42018 PyObject *result;
42019 PyObject * obj0 = 0 ;
42020 char *kwnames[] = {
42021 (char *) "self", NULL
42022 };
42023
42024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42026 if (SWIG_arg_fail(1)) SWIG_fail;
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 result = (PyObject *)wxGBPosition_Get(arg1);
42030
42031 wxPyEndAllowThreads(__tstate);
42032 if (PyErr_Occurred()) SWIG_fail;
42033 }
42034 resultobj = result;
42035 return resultobj;
42036 fail:
42037 return NULL;
42038 }
42039
42040
42041 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42042 PyObject *obj;
42043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42044 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42045 Py_INCREF(obj);
42046 return Py_BuildValue((char *)"");
42047 }
42048 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42049 PyObject *resultobj;
42050 int arg1 = (int) 1 ;
42051 int arg2 = (int) 1 ;
42052 wxGBSpan *result;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 char *kwnames[] = {
42056 (char *) "rowspan",(char *) "colspan", NULL
42057 };
42058
42059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42060 if (obj0) {
42061 {
42062 arg1 = (int)(SWIG_As_int(obj0));
42063 if (SWIG_arg_fail(1)) SWIG_fail;
42064 }
42065 }
42066 if (obj1) {
42067 {
42068 arg2 = (int)(SWIG_As_int(obj1));
42069 if (SWIG_arg_fail(2)) SWIG_fail;
42070 }
42071 }
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42075
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42080 return resultobj;
42081 fail:
42082 return NULL;
42083 }
42084
42085
42086 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42087 PyObject *resultobj;
42088 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42089 int result;
42090 PyObject * obj0 = 0 ;
42091 char *kwnames[] = {
42092 (char *) "self", NULL
42093 };
42094
42095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42097 if (SWIG_arg_fail(1)) SWIG_fail;
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42101
42102 wxPyEndAllowThreads(__tstate);
42103 if (PyErr_Occurred()) SWIG_fail;
42104 }
42105 {
42106 resultobj = SWIG_From_int((int)(result));
42107 }
42108 return resultobj;
42109 fail:
42110 return NULL;
42111 }
42112
42113
42114 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42115 PyObject *resultobj;
42116 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42117 int result;
42118 PyObject * obj0 = 0 ;
42119 char *kwnames[] = {
42120 (char *) "self", NULL
42121 };
42122
42123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42125 if (SWIG_arg_fail(1)) SWIG_fail;
42126 {
42127 PyThreadState* __tstate = wxPyBeginAllowThreads();
42128 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42129
42130 wxPyEndAllowThreads(__tstate);
42131 if (PyErr_Occurred()) SWIG_fail;
42132 }
42133 {
42134 resultobj = SWIG_From_int((int)(result));
42135 }
42136 return resultobj;
42137 fail:
42138 return NULL;
42139 }
42140
42141
42142 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42143 PyObject *resultobj;
42144 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42145 int arg2 ;
42146 PyObject * obj0 = 0 ;
42147 PyObject * obj1 = 0 ;
42148 char *kwnames[] = {
42149 (char *) "self",(char *) "rowspan", NULL
42150 };
42151
42152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42154 if (SWIG_arg_fail(1)) SWIG_fail;
42155 {
42156 arg2 = (int)(SWIG_As_int(obj1));
42157 if (SWIG_arg_fail(2)) SWIG_fail;
42158 }
42159 {
42160 PyThreadState* __tstate = wxPyBeginAllowThreads();
42161 (arg1)->SetRowspan(arg2);
42162
42163 wxPyEndAllowThreads(__tstate);
42164 if (PyErr_Occurred()) SWIG_fail;
42165 }
42166 Py_INCREF(Py_None); resultobj = Py_None;
42167 return resultobj;
42168 fail:
42169 return NULL;
42170 }
42171
42172
42173 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42174 PyObject *resultobj;
42175 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42176 int arg2 ;
42177 PyObject * obj0 = 0 ;
42178 PyObject * obj1 = 0 ;
42179 char *kwnames[] = {
42180 (char *) "self",(char *) "colspan", NULL
42181 };
42182
42183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42185 if (SWIG_arg_fail(1)) SWIG_fail;
42186 {
42187 arg2 = (int)(SWIG_As_int(obj1));
42188 if (SWIG_arg_fail(2)) SWIG_fail;
42189 }
42190 {
42191 PyThreadState* __tstate = wxPyBeginAllowThreads();
42192 (arg1)->SetColspan(arg2);
42193
42194 wxPyEndAllowThreads(__tstate);
42195 if (PyErr_Occurred()) SWIG_fail;
42196 }
42197 Py_INCREF(Py_None); resultobj = Py_None;
42198 return resultobj;
42199 fail:
42200 return NULL;
42201 }
42202
42203
42204 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42205 PyObject *resultobj;
42206 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42207 wxGBSpan *arg2 = 0 ;
42208 bool result;
42209 wxGBSpan temp2 ;
42210 PyObject * obj0 = 0 ;
42211 PyObject * obj1 = 0 ;
42212 char *kwnames[] = {
42213 (char *) "self",(char *) "other", NULL
42214 };
42215
42216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42218 if (SWIG_arg_fail(1)) SWIG_fail;
42219 {
42220 arg2 = &temp2;
42221 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42222 }
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42226
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 {
42231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42232 }
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42240 PyObject *resultobj;
42241 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42242 wxGBSpan *arg2 = 0 ;
42243 bool result;
42244 wxGBSpan temp2 ;
42245 PyObject * obj0 = 0 ;
42246 PyObject * obj1 = 0 ;
42247 char *kwnames[] = {
42248 (char *) "self",(char *) "other", NULL
42249 };
42250
42251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42253 if (SWIG_arg_fail(1)) SWIG_fail;
42254 {
42255 arg2 = &temp2;
42256 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42257 }
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42261
42262 wxPyEndAllowThreads(__tstate);
42263 if (PyErr_Occurred()) SWIG_fail;
42264 }
42265 {
42266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42267 }
42268 return resultobj;
42269 fail:
42270 return NULL;
42271 }
42272
42273
42274 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42275 PyObject *resultobj;
42276 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42277 int arg2 = (int) 1 ;
42278 int arg3 = (int) 1 ;
42279 PyObject * obj0 = 0 ;
42280 PyObject * obj1 = 0 ;
42281 PyObject * obj2 = 0 ;
42282 char *kwnames[] = {
42283 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42284 };
42285
42286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42288 if (SWIG_arg_fail(1)) SWIG_fail;
42289 if (obj1) {
42290 {
42291 arg2 = (int)(SWIG_As_int(obj1));
42292 if (SWIG_arg_fail(2)) SWIG_fail;
42293 }
42294 }
42295 if (obj2) {
42296 {
42297 arg3 = (int)(SWIG_As_int(obj2));
42298 if (SWIG_arg_fail(3)) SWIG_fail;
42299 }
42300 }
42301 {
42302 PyThreadState* __tstate = wxPyBeginAllowThreads();
42303 wxGBSpan_Set(arg1,arg2,arg3);
42304
42305 wxPyEndAllowThreads(__tstate);
42306 if (PyErr_Occurred()) SWIG_fail;
42307 }
42308 Py_INCREF(Py_None); resultobj = Py_None;
42309 return resultobj;
42310 fail:
42311 return NULL;
42312 }
42313
42314
42315 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42316 PyObject *resultobj;
42317 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42318 PyObject *result;
42319 PyObject * obj0 = 0 ;
42320 char *kwnames[] = {
42321 (char *) "self", NULL
42322 };
42323
42324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42326 if (SWIG_arg_fail(1)) SWIG_fail;
42327 {
42328 PyThreadState* __tstate = wxPyBeginAllowThreads();
42329 result = (PyObject *)wxGBSpan_Get(arg1);
42330
42331 wxPyEndAllowThreads(__tstate);
42332 if (PyErr_Occurred()) SWIG_fail;
42333 }
42334 resultobj = result;
42335 return resultobj;
42336 fail:
42337 return NULL;
42338 }
42339
42340
42341 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42342 PyObject *obj;
42343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42344 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42345 Py_INCREF(obj);
42346 return Py_BuildValue((char *)"");
42347 }
42348 static int _wrap_DefaultSpan_set(PyObject *) {
42349 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42350 return 1;
42351 }
42352
42353
42354 static PyObject *_wrap_DefaultSpan_get(void) {
42355 PyObject *pyobj;
42356
42357 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42358 return pyobj;
42359 }
42360
42361
42362 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42363 PyObject *resultobj;
42364 wxGBSizerItem *result;
42365 char *kwnames[] = {
42366 NULL
42367 };
42368
42369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42370 {
42371 PyThreadState* __tstate = wxPyBeginAllowThreads();
42372 result = (wxGBSizerItem *)new wxGBSizerItem();
42373
42374 wxPyEndAllowThreads(__tstate);
42375 if (PyErr_Occurred()) SWIG_fail;
42376 }
42377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42378 return resultobj;
42379 fail:
42380 return NULL;
42381 }
42382
42383
42384 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42385 PyObject *resultobj;
42386 wxWindow *arg1 = (wxWindow *) 0 ;
42387 wxGBPosition *arg2 = 0 ;
42388 wxGBSpan *arg3 = 0 ;
42389 int arg4 ;
42390 int arg5 ;
42391 PyObject *arg6 = (PyObject *) NULL ;
42392 wxGBSizerItem *result;
42393 wxGBPosition temp2 ;
42394 wxGBSpan temp3 ;
42395 PyObject * obj0 = 0 ;
42396 PyObject * obj1 = 0 ;
42397 PyObject * obj2 = 0 ;
42398 PyObject * obj3 = 0 ;
42399 PyObject * obj4 = 0 ;
42400 PyObject * obj5 = 0 ;
42401 char *kwnames[] = {
42402 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42403 };
42404
42405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42407 if (SWIG_arg_fail(1)) SWIG_fail;
42408 {
42409 arg2 = &temp2;
42410 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42411 }
42412 {
42413 arg3 = &temp3;
42414 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42415 }
42416 {
42417 arg4 = (int)(SWIG_As_int(obj3));
42418 if (SWIG_arg_fail(4)) SWIG_fail;
42419 }
42420 {
42421 arg5 = (int)(SWIG_As_int(obj4));
42422 if (SWIG_arg_fail(5)) SWIG_fail;
42423 }
42424 if (obj5) {
42425 arg6 = obj5;
42426 }
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42430
42431 wxPyEndAllowThreads(__tstate);
42432 if (PyErr_Occurred()) SWIG_fail;
42433 }
42434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42435 return resultobj;
42436 fail:
42437 return NULL;
42438 }
42439
42440
42441 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42442 PyObject *resultobj;
42443 wxSizer *arg1 = (wxSizer *) 0 ;
42444 wxGBPosition *arg2 = 0 ;
42445 wxGBSpan *arg3 = 0 ;
42446 int arg4 ;
42447 int arg5 ;
42448 PyObject *arg6 = (PyObject *) NULL ;
42449 wxGBSizerItem *result;
42450 wxGBPosition temp2 ;
42451 wxGBSpan temp3 ;
42452 PyObject * obj0 = 0 ;
42453 PyObject * obj1 = 0 ;
42454 PyObject * obj2 = 0 ;
42455 PyObject * obj3 = 0 ;
42456 PyObject * obj4 = 0 ;
42457 PyObject * obj5 = 0 ;
42458 char *kwnames[] = {
42459 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42460 };
42461
42462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42464 if (SWIG_arg_fail(1)) SWIG_fail;
42465 {
42466 arg2 = &temp2;
42467 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42468 }
42469 {
42470 arg3 = &temp3;
42471 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42472 }
42473 {
42474 arg4 = (int)(SWIG_As_int(obj3));
42475 if (SWIG_arg_fail(4)) SWIG_fail;
42476 }
42477 {
42478 arg5 = (int)(SWIG_As_int(obj4));
42479 if (SWIG_arg_fail(5)) SWIG_fail;
42480 }
42481 if (obj5) {
42482 arg6 = obj5;
42483 }
42484 {
42485 PyThreadState* __tstate = wxPyBeginAllowThreads();
42486 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42487
42488 wxPyEndAllowThreads(__tstate);
42489 if (PyErr_Occurred()) SWIG_fail;
42490 }
42491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42492 return resultobj;
42493 fail:
42494 return NULL;
42495 }
42496
42497
42498 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42499 PyObject *resultobj;
42500 int arg1 ;
42501 int arg2 ;
42502 wxGBPosition *arg3 = 0 ;
42503 wxGBSpan *arg4 = 0 ;
42504 int arg5 ;
42505 int arg6 ;
42506 PyObject *arg7 = (PyObject *) NULL ;
42507 wxGBSizerItem *result;
42508 wxGBPosition temp3 ;
42509 wxGBSpan temp4 ;
42510 PyObject * obj0 = 0 ;
42511 PyObject * obj1 = 0 ;
42512 PyObject * obj2 = 0 ;
42513 PyObject * obj3 = 0 ;
42514 PyObject * obj4 = 0 ;
42515 PyObject * obj5 = 0 ;
42516 PyObject * obj6 = 0 ;
42517 char *kwnames[] = {
42518 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42519 };
42520
42521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42522 {
42523 arg1 = (int)(SWIG_As_int(obj0));
42524 if (SWIG_arg_fail(1)) SWIG_fail;
42525 }
42526 {
42527 arg2 = (int)(SWIG_As_int(obj1));
42528 if (SWIG_arg_fail(2)) SWIG_fail;
42529 }
42530 {
42531 arg3 = &temp3;
42532 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42533 }
42534 {
42535 arg4 = &temp4;
42536 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42537 }
42538 {
42539 arg5 = (int)(SWIG_As_int(obj4));
42540 if (SWIG_arg_fail(5)) SWIG_fail;
42541 }
42542 {
42543 arg6 = (int)(SWIG_As_int(obj5));
42544 if (SWIG_arg_fail(6)) SWIG_fail;
42545 }
42546 if (obj6) {
42547 arg7 = obj6;
42548 }
42549 {
42550 PyThreadState* __tstate = wxPyBeginAllowThreads();
42551 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42552
42553 wxPyEndAllowThreads(__tstate);
42554 if (PyErr_Occurred()) SWIG_fail;
42555 }
42556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42557 return resultobj;
42558 fail:
42559 return NULL;
42560 }
42561
42562
42563 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42564 PyObject *resultobj;
42565 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42566 wxGBPosition result;
42567 PyObject * obj0 = 0 ;
42568 char *kwnames[] = {
42569 (char *) "self", NULL
42570 };
42571
42572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42574 if (SWIG_arg_fail(1)) SWIG_fail;
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = ((wxGBSizerItem const *)arg1)->GetPos();
42578
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 wxGBPosition * resultptr;
42584 resultptr = new wxGBPosition((wxGBPosition &)(result));
42585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42586 }
42587 return resultobj;
42588 fail:
42589 return NULL;
42590 }
42591
42592
42593 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42594 PyObject *resultobj;
42595 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42596 wxGBSpan result;
42597 PyObject * obj0 = 0 ;
42598 char *kwnames[] = {
42599 (char *) "self", NULL
42600 };
42601
42602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42604 if (SWIG_arg_fail(1)) SWIG_fail;
42605 {
42606 PyThreadState* __tstate = wxPyBeginAllowThreads();
42607 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42608
42609 wxPyEndAllowThreads(__tstate);
42610 if (PyErr_Occurred()) SWIG_fail;
42611 }
42612 {
42613 wxGBSpan * resultptr;
42614 resultptr = new wxGBSpan((wxGBSpan &)(result));
42615 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42616 }
42617 return resultobj;
42618 fail:
42619 return NULL;
42620 }
42621
42622
42623 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42624 PyObject *resultobj;
42625 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42626 wxGBPosition *arg2 = 0 ;
42627 bool result;
42628 wxGBPosition temp2 ;
42629 PyObject * obj0 = 0 ;
42630 PyObject * obj1 = 0 ;
42631 char *kwnames[] = {
42632 (char *) "self",(char *) "pos", NULL
42633 };
42634
42635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42637 if (SWIG_arg_fail(1)) SWIG_fail;
42638 {
42639 arg2 = &temp2;
42640 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42641 }
42642 {
42643 PyThreadState* __tstate = wxPyBeginAllowThreads();
42644 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42645
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 {
42650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42651 }
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42659 PyObject *resultobj;
42660 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42661 wxGBSpan *arg2 = 0 ;
42662 bool result;
42663 wxGBSpan temp2 ;
42664 PyObject * obj0 = 0 ;
42665 PyObject * obj1 = 0 ;
42666 char *kwnames[] = {
42667 (char *) "self",(char *) "span", NULL
42668 };
42669
42670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42672 if (SWIG_arg_fail(1)) SWIG_fail;
42673 {
42674 arg2 = &temp2;
42675 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42676 }
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42680
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 {
42685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42686 }
42687 return resultobj;
42688 fail:
42689 return NULL;
42690 }
42691
42692
42693 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42694 PyObject *resultobj;
42695 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42696 wxGBSizerItem *arg2 = 0 ;
42697 bool result;
42698 PyObject * obj0 = 0 ;
42699 PyObject * obj1 = 0 ;
42700 char *kwnames[] = {
42701 (char *) "self",(char *) "other", NULL
42702 };
42703
42704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42706 if (SWIG_arg_fail(1)) SWIG_fail;
42707 {
42708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42709 if (SWIG_arg_fail(2)) SWIG_fail;
42710 if (arg2 == NULL) {
42711 SWIG_null_ref("wxGBSizerItem");
42712 }
42713 if (SWIG_arg_fail(2)) SWIG_fail;
42714 }
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42718
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 {
42723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42724 }
42725 return resultobj;
42726 fail:
42727 return NULL;
42728 }
42729
42730
42731 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42732 PyObject *resultobj;
42733 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42734 wxGBPosition *arg2 = 0 ;
42735 wxGBSpan *arg3 = 0 ;
42736 bool result;
42737 wxGBPosition temp2 ;
42738 wxGBSpan temp3 ;
42739 PyObject * obj0 = 0 ;
42740 PyObject * obj1 = 0 ;
42741 PyObject * obj2 = 0 ;
42742 char *kwnames[] = {
42743 (char *) "self",(char *) "pos",(char *) "span", NULL
42744 };
42745
42746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42748 if (SWIG_arg_fail(1)) SWIG_fail;
42749 {
42750 arg2 = &temp2;
42751 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42752 }
42753 {
42754 arg3 = &temp3;
42755 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42756 }
42757 {
42758 PyThreadState* __tstate = wxPyBeginAllowThreads();
42759 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42760
42761 wxPyEndAllowThreads(__tstate);
42762 if (PyErr_Occurred()) SWIG_fail;
42763 }
42764 {
42765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42766 }
42767 return resultobj;
42768 fail:
42769 return NULL;
42770 }
42771
42772
42773 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42774 PyObject *resultobj;
42775 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42776 wxGBPosition result;
42777 PyObject * obj0 = 0 ;
42778 char *kwnames[] = {
42779 (char *) "self", NULL
42780 };
42781
42782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42784 if (SWIG_arg_fail(1)) SWIG_fail;
42785 {
42786 PyThreadState* __tstate = wxPyBeginAllowThreads();
42787 result = wxGBSizerItem_GetEndPos(arg1);
42788
42789 wxPyEndAllowThreads(__tstate);
42790 if (PyErr_Occurred()) SWIG_fail;
42791 }
42792 {
42793 wxGBPosition * resultptr;
42794 resultptr = new wxGBPosition((wxGBPosition &)(result));
42795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42796 }
42797 return resultobj;
42798 fail:
42799 return NULL;
42800 }
42801
42802
42803 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42804 PyObject *resultobj;
42805 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42806 wxGridBagSizer *result;
42807 PyObject * obj0 = 0 ;
42808 char *kwnames[] = {
42809 (char *) "self", NULL
42810 };
42811
42812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42814 if (SWIG_arg_fail(1)) SWIG_fail;
42815 {
42816 PyThreadState* __tstate = wxPyBeginAllowThreads();
42817 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42818
42819 wxPyEndAllowThreads(__tstate);
42820 if (PyErr_Occurred()) SWIG_fail;
42821 }
42822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42823 return resultobj;
42824 fail:
42825 return NULL;
42826 }
42827
42828
42829 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42830 PyObject *resultobj;
42831 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42832 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42833 PyObject * obj0 = 0 ;
42834 PyObject * obj1 = 0 ;
42835 char *kwnames[] = {
42836 (char *) "self",(char *) "sizer", NULL
42837 };
42838
42839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42841 if (SWIG_arg_fail(1)) SWIG_fail;
42842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42843 if (SWIG_arg_fail(2)) SWIG_fail;
42844 {
42845 PyThreadState* __tstate = wxPyBeginAllowThreads();
42846 (arg1)->SetGBSizer(arg2);
42847
42848 wxPyEndAllowThreads(__tstate);
42849 if (PyErr_Occurred()) SWIG_fail;
42850 }
42851 Py_INCREF(Py_None); resultobj = Py_None;
42852 return resultobj;
42853 fail:
42854 return NULL;
42855 }
42856
42857
42858 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42859 PyObject *obj;
42860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42861 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42862 Py_INCREF(obj);
42863 return Py_BuildValue((char *)"");
42864 }
42865 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42866 PyObject *resultobj;
42867 int arg1 = (int) 0 ;
42868 int arg2 = (int) 0 ;
42869 wxGridBagSizer *result;
42870 PyObject * obj0 = 0 ;
42871 PyObject * obj1 = 0 ;
42872 char *kwnames[] = {
42873 (char *) "vgap",(char *) "hgap", NULL
42874 };
42875
42876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42877 if (obj0) {
42878 {
42879 arg1 = (int)(SWIG_As_int(obj0));
42880 if (SWIG_arg_fail(1)) SWIG_fail;
42881 }
42882 }
42883 if (obj1) {
42884 {
42885 arg2 = (int)(SWIG_As_int(obj1));
42886 if (SWIG_arg_fail(2)) SWIG_fail;
42887 }
42888 }
42889 {
42890 PyThreadState* __tstate = wxPyBeginAllowThreads();
42891 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42892
42893 wxPyEndAllowThreads(__tstate);
42894 if (PyErr_Occurred()) SWIG_fail;
42895 }
42896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42897 return resultobj;
42898 fail:
42899 return NULL;
42900 }
42901
42902
42903 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42904 PyObject *resultobj;
42905 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42906 PyObject *arg2 = (PyObject *) 0 ;
42907 wxGBPosition *arg3 = 0 ;
42908 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42909 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42910 int arg5 = (int) 0 ;
42911 int arg6 = (int) 0 ;
42912 PyObject *arg7 = (PyObject *) NULL ;
42913 wxGBSizerItem *result;
42914 wxGBPosition temp3 ;
42915 wxGBSpan temp4 ;
42916 PyObject * obj0 = 0 ;
42917 PyObject * obj1 = 0 ;
42918 PyObject * obj2 = 0 ;
42919 PyObject * obj3 = 0 ;
42920 PyObject * obj4 = 0 ;
42921 PyObject * obj5 = 0 ;
42922 PyObject * obj6 = 0 ;
42923 char *kwnames[] = {
42924 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42925 };
42926
42927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42929 if (SWIG_arg_fail(1)) SWIG_fail;
42930 arg2 = obj1;
42931 {
42932 arg3 = &temp3;
42933 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42934 }
42935 if (obj3) {
42936 {
42937 arg4 = &temp4;
42938 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42939 }
42940 }
42941 if (obj4) {
42942 {
42943 arg5 = (int)(SWIG_As_int(obj4));
42944 if (SWIG_arg_fail(5)) SWIG_fail;
42945 }
42946 }
42947 if (obj5) {
42948 {
42949 arg6 = (int)(SWIG_As_int(obj5));
42950 if (SWIG_arg_fail(6)) SWIG_fail;
42951 }
42952 }
42953 if (obj6) {
42954 arg7 = obj6;
42955 }
42956 {
42957 PyThreadState* __tstate = wxPyBeginAllowThreads();
42958 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42959
42960 wxPyEndAllowThreads(__tstate);
42961 if (PyErr_Occurred()) SWIG_fail;
42962 }
42963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42964 return resultobj;
42965 fail:
42966 return NULL;
42967 }
42968
42969
42970 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42971 PyObject *resultobj;
42972 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42973 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42974 wxGBSizerItem *result;
42975 PyObject * obj0 = 0 ;
42976 PyObject * obj1 = 0 ;
42977 char *kwnames[] = {
42978 (char *) "self",(char *) "item", NULL
42979 };
42980
42981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42983 if (SWIG_arg_fail(1)) SWIG_fail;
42984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42985 if (SWIG_arg_fail(2)) SWIG_fail;
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42989
42990 wxPyEndAllowThreads(__tstate);
42991 if (PyErr_Occurred()) SWIG_fail;
42992 }
42993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42994 return resultobj;
42995 fail:
42996 return NULL;
42997 }
42998
42999
43000 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43001 PyObject *resultobj;
43002 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43003 int arg2 ;
43004 int arg3 ;
43005 wxSize result;
43006 PyObject * obj0 = 0 ;
43007 PyObject * obj1 = 0 ;
43008 PyObject * obj2 = 0 ;
43009 char *kwnames[] = {
43010 (char *) "self",(char *) "row",(char *) "col", NULL
43011 };
43012
43013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43015 if (SWIG_arg_fail(1)) SWIG_fail;
43016 {
43017 arg2 = (int)(SWIG_As_int(obj1));
43018 if (SWIG_arg_fail(2)) SWIG_fail;
43019 }
43020 {
43021 arg3 = (int)(SWIG_As_int(obj2));
43022 if (SWIG_arg_fail(3)) SWIG_fail;
43023 }
43024 {
43025 PyThreadState* __tstate = wxPyBeginAllowThreads();
43026 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43027
43028 wxPyEndAllowThreads(__tstate);
43029 if (PyErr_Occurred()) SWIG_fail;
43030 }
43031 {
43032 wxSize * resultptr;
43033 resultptr = new wxSize((wxSize &)(result));
43034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43035 }
43036 return resultobj;
43037 fail:
43038 return NULL;
43039 }
43040
43041
43042 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43043 PyObject *resultobj;
43044 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43045 wxSize result;
43046 PyObject * obj0 = 0 ;
43047 char *kwnames[] = {
43048 (char *) "self", NULL
43049 };
43050
43051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43053 if (SWIG_arg_fail(1)) SWIG_fail;
43054 {
43055 PyThreadState* __tstate = wxPyBeginAllowThreads();
43056 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43057
43058 wxPyEndAllowThreads(__tstate);
43059 if (PyErr_Occurred()) SWIG_fail;
43060 }
43061 {
43062 wxSize * resultptr;
43063 resultptr = new wxSize((wxSize &)(result));
43064 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43065 }
43066 return resultobj;
43067 fail:
43068 return NULL;
43069 }
43070
43071
43072 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43073 PyObject *resultobj;
43074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43075 wxSize *arg2 = 0 ;
43076 wxSize temp2 ;
43077 PyObject * obj0 = 0 ;
43078 PyObject * obj1 = 0 ;
43079 char *kwnames[] = {
43080 (char *) "self",(char *) "sz", NULL
43081 };
43082
43083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43085 if (SWIG_arg_fail(1)) SWIG_fail;
43086 {
43087 arg2 = &temp2;
43088 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43089 }
43090 {
43091 PyThreadState* __tstate = wxPyBeginAllowThreads();
43092 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43093
43094 wxPyEndAllowThreads(__tstate);
43095 if (PyErr_Occurred()) SWIG_fail;
43096 }
43097 Py_INCREF(Py_None); resultobj = Py_None;
43098 return resultobj;
43099 fail:
43100 return NULL;
43101 }
43102
43103
43104 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43105 PyObject *resultobj;
43106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43107 wxWindow *arg2 = (wxWindow *) 0 ;
43108 wxGBPosition result;
43109 PyObject * obj0 = 0 ;
43110 PyObject * obj1 = 0 ;
43111
43112 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43114 if (SWIG_arg_fail(1)) SWIG_fail;
43115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43116 if (SWIG_arg_fail(2)) SWIG_fail;
43117 {
43118 PyThreadState* __tstate = wxPyBeginAllowThreads();
43119 result = (arg1)->GetItemPosition(arg2);
43120
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 {
43125 wxGBPosition * resultptr;
43126 resultptr = new wxGBPosition((wxGBPosition &)(result));
43127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43128 }
43129 return resultobj;
43130 fail:
43131 return NULL;
43132 }
43133
43134
43135 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43136 PyObject *resultobj;
43137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43138 wxSizer *arg2 = (wxSizer *) 0 ;
43139 wxGBPosition result;
43140 PyObject * obj0 = 0 ;
43141 PyObject * obj1 = 0 ;
43142
43143 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43145 if (SWIG_arg_fail(1)) SWIG_fail;
43146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43147 if (SWIG_arg_fail(2)) SWIG_fail;
43148 {
43149 PyThreadState* __tstate = wxPyBeginAllowThreads();
43150 result = (arg1)->GetItemPosition(arg2);
43151
43152 wxPyEndAllowThreads(__tstate);
43153 if (PyErr_Occurred()) SWIG_fail;
43154 }
43155 {
43156 wxGBPosition * resultptr;
43157 resultptr = new wxGBPosition((wxGBPosition &)(result));
43158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43159 }
43160 return resultobj;
43161 fail:
43162 return NULL;
43163 }
43164
43165
43166 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43167 PyObject *resultobj;
43168 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43169 size_t arg2 ;
43170 wxGBPosition result;
43171 PyObject * obj0 = 0 ;
43172 PyObject * obj1 = 0 ;
43173
43174 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43176 if (SWIG_arg_fail(1)) SWIG_fail;
43177 {
43178 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43179 if (SWIG_arg_fail(2)) SWIG_fail;
43180 }
43181 {
43182 PyThreadState* __tstate = wxPyBeginAllowThreads();
43183 result = (arg1)->GetItemPosition(arg2);
43184
43185 wxPyEndAllowThreads(__tstate);
43186 if (PyErr_Occurred()) SWIG_fail;
43187 }
43188 {
43189 wxGBPosition * resultptr;
43190 resultptr = new wxGBPosition((wxGBPosition &)(result));
43191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43192 }
43193 return resultobj;
43194 fail:
43195 return NULL;
43196 }
43197
43198
43199 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43200 int argc;
43201 PyObject *argv[3];
43202 int ii;
43203
43204 argc = PyObject_Length(args);
43205 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43206 argv[ii] = PyTuple_GetItem(args,ii);
43207 }
43208 if (argc == 2) {
43209 int _v;
43210 {
43211 void *ptr;
43212 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43213 _v = 0;
43214 PyErr_Clear();
43215 } else {
43216 _v = 1;
43217 }
43218 }
43219 if (_v) {
43220 {
43221 void *ptr;
43222 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43223 _v = 0;
43224 PyErr_Clear();
43225 } else {
43226 _v = 1;
43227 }
43228 }
43229 if (_v) {
43230 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43231 }
43232 }
43233 }
43234 if (argc == 2) {
43235 int _v;
43236 {
43237 void *ptr;
43238 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43239 _v = 0;
43240 PyErr_Clear();
43241 } else {
43242 _v = 1;
43243 }
43244 }
43245 if (_v) {
43246 {
43247 void *ptr;
43248 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43249 _v = 0;
43250 PyErr_Clear();
43251 } else {
43252 _v = 1;
43253 }
43254 }
43255 if (_v) {
43256 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43257 }
43258 }
43259 }
43260 if (argc == 2) {
43261 int _v;
43262 {
43263 void *ptr;
43264 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43265 _v = 0;
43266 PyErr_Clear();
43267 } else {
43268 _v = 1;
43269 }
43270 }
43271 if (_v) {
43272 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43273 if (_v) {
43274 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43275 }
43276 }
43277 }
43278
43279 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43280 return NULL;
43281 }
43282
43283
43284 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43285 PyObject *resultobj;
43286 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43287 wxWindow *arg2 = (wxWindow *) 0 ;
43288 wxGBPosition *arg3 = 0 ;
43289 bool result;
43290 wxGBPosition temp3 ;
43291 PyObject * obj0 = 0 ;
43292 PyObject * obj1 = 0 ;
43293 PyObject * obj2 = 0 ;
43294
43295 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43297 if (SWIG_arg_fail(1)) SWIG_fail;
43298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43299 if (SWIG_arg_fail(2)) SWIG_fail;
43300 {
43301 arg3 = &temp3;
43302 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43303 }
43304 {
43305 PyThreadState* __tstate = wxPyBeginAllowThreads();
43306 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43307
43308 wxPyEndAllowThreads(__tstate);
43309 if (PyErr_Occurred()) SWIG_fail;
43310 }
43311 {
43312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43313 }
43314 return resultobj;
43315 fail:
43316 return NULL;
43317 }
43318
43319
43320 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43321 PyObject *resultobj;
43322 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43323 wxSizer *arg2 = (wxSizer *) 0 ;
43324 wxGBPosition *arg3 = 0 ;
43325 bool result;
43326 wxGBPosition temp3 ;
43327 PyObject * obj0 = 0 ;
43328 PyObject * obj1 = 0 ;
43329 PyObject * obj2 = 0 ;
43330
43331 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43333 if (SWIG_arg_fail(1)) SWIG_fail;
43334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43335 if (SWIG_arg_fail(2)) SWIG_fail;
43336 {
43337 arg3 = &temp3;
43338 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43339 }
43340 {
43341 PyThreadState* __tstate = wxPyBeginAllowThreads();
43342 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43343
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 {
43348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43349 }
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43357 PyObject *resultobj;
43358 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43359 size_t arg2 ;
43360 wxGBPosition *arg3 = 0 ;
43361 bool result;
43362 wxGBPosition temp3 ;
43363 PyObject * obj0 = 0 ;
43364 PyObject * obj1 = 0 ;
43365 PyObject * obj2 = 0 ;
43366
43367 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43369 if (SWIG_arg_fail(1)) SWIG_fail;
43370 {
43371 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43372 if (SWIG_arg_fail(2)) SWIG_fail;
43373 }
43374 {
43375 arg3 = &temp3;
43376 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43377 }
43378 {
43379 PyThreadState* __tstate = wxPyBeginAllowThreads();
43380 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43381
43382 wxPyEndAllowThreads(__tstate);
43383 if (PyErr_Occurred()) SWIG_fail;
43384 }
43385 {
43386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43387 }
43388 return resultobj;
43389 fail:
43390 return NULL;
43391 }
43392
43393
43394 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43395 int argc;
43396 PyObject *argv[4];
43397 int ii;
43398
43399 argc = PyObject_Length(args);
43400 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43401 argv[ii] = PyTuple_GetItem(args,ii);
43402 }
43403 if (argc == 3) {
43404 int _v;
43405 {
43406 void *ptr;
43407 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43408 _v = 0;
43409 PyErr_Clear();
43410 } else {
43411 _v = 1;
43412 }
43413 }
43414 if (_v) {
43415 {
43416 void *ptr;
43417 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43418 _v = 0;
43419 PyErr_Clear();
43420 } else {
43421 _v = 1;
43422 }
43423 }
43424 if (_v) {
43425 {
43426 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43427 }
43428 if (_v) {
43429 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43430 }
43431 }
43432 }
43433 }
43434 if (argc == 3) {
43435 int _v;
43436 {
43437 void *ptr;
43438 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43439 _v = 0;
43440 PyErr_Clear();
43441 } else {
43442 _v = 1;
43443 }
43444 }
43445 if (_v) {
43446 {
43447 void *ptr;
43448 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43449 _v = 0;
43450 PyErr_Clear();
43451 } else {
43452 _v = 1;
43453 }
43454 }
43455 if (_v) {
43456 {
43457 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43458 }
43459 if (_v) {
43460 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43461 }
43462 }
43463 }
43464 }
43465 if (argc == 3) {
43466 int _v;
43467 {
43468 void *ptr;
43469 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43470 _v = 0;
43471 PyErr_Clear();
43472 } else {
43473 _v = 1;
43474 }
43475 }
43476 if (_v) {
43477 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43478 if (_v) {
43479 {
43480 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43481 }
43482 if (_v) {
43483 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43484 }
43485 }
43486 }
43487 }
43488
43489 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43490 return NULL;
43491 }
43492
43493
43494 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43495 PyObject *resultobj;
43496 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43497 wxWindow *arg2 = (wxWindow *) 0 ;
43498 wxGBSpan result;
43499 PyObject * obj0 = 0 ;
43500 PyObject * obj1 = 0 ;
43501
43502 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43504 if (SWIG_arg_fail(1)) SWIG_fail;
43505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43506 if (SWIG_arg_fail(2)) SWIG_fail;
43507 {
43508 PyThreadState* __tstate = wxPyBeginAllowThreads();
43509 result = (arg1)->GetItemSpan(arg2);
43510
43511 wxPyEndAllowThreads(__tstate);
43512 if (PyErr_Occurred()) SWIG_fail;
43513 }
43514 {
43515 wxGBSpan * resultptr;
43516 resultptr = new wxGBSpan((wxGBSpan &)(result));
43517 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43518 }
43519 return resultobj;
43520 fail:
43521 return NULL;
43522 }
43523
43524
43525 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43526 PyObject *resultobj;
43527 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43528 wxSizer *arg2 = (wxSizer *) 0 ;
43529 wxGBSpan result;
43530 PyObject * obj0 = 0 ;
43531 PyObject * obj1 = 0 ;
43532
43533 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43535 if (SWIG_arg_fail(1)) SWIG_fail;
43536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43537 if (SWIG_arg_fail(2)) SWIG_fail;
43538 {
43539 PyThreadState* __tstate = wxPyBeginAllowThreads();
43540 result = (arg1)->GetItemSpan(arg2);
43541
43542 wxPyEndAllowThreads(__tstate);
43543 if (PyErr_Occurred()) SWIG_fail;
43544 }
43545 {
43546 wxGBSpan * resultptr;
43547 resultptr = new wxGBSpan((wxGBSpan &)(result));
43548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43549 }
43550 return resultobj;
43551 fail:
43552 return NULL;
43553 }
43554
43555
43556 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43557 PyObject *resultobj;
43558 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43559 size_t arg2 ;
43560 wxGBSpan result;
43561 PyObject * obj0 = 0 ;
43562 PyObject * obj1 = 0 ;
43563
43564 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43566 if (SWIG_arg_fail(1)) SWIG_fail;
43567 {
43568 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43569 if (SWIG_arg_fail(2)) SWIG_fail;
43570 }
43571 {
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 result = (arg1)->GetItemSpan(arg2);
43574
43575 wxPyEndAllowThreads(__tstate);
43576 if (PyErr_Occurred()) SWIG_fail;
43577 }
43578 {
43579 wxGBSpan * resultptr;
43580 resultptr = new wxGBSpan((wxGBSpan &)(result));
43581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43582 }
43583 return resultobj;
43584 fail:
43585 return NULL;
43586 }
43587
43588
43589 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43590 int argc;
43591 PyObject *argv[3];
43592 int ii;
43593
43594 argc = PyObject_Length(args);
43595 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43596 argv[ii] = PyTuple_GetItem(args,ii);
43597 }
43598 if (argc == 2) {
43599 int _v;
43600 {
43601 void *ptr;
43602 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43603 _v = 0;
43604 PyErr_Clear();
43605 } else {
43606 _v = 1;
43607 }
43608 }
43609 if (_v) {
43610 {
43611 void *ptr;
43612 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43613 _v = 0;
43614 PyErr_Clear();
43615 } else {
43616 _v = 1;
43617 }
43618 }
43619 if (_v) {
43620 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43621 }
43622 }
43623 }
43624 if (argc == 2) {
43625 int _v;
43626 {
43627 void *ptr;
43628 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43629 _v = 0;
43630 PyErr_Clear();
43631 } else {
43632 _v = 1;
43633 }
43634 }
43635 if (_v) {
43636 {
43637 void *ptr;
43638 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43639 _v = 0;
43640 PyErr_Clear();
43641 } else {
43642 _v = 1;
43643 }
43644 }
43645 if (_v) {
43646 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43647 }
43648 }
43649 }
43650 if (argc == 2) {
43651 int _v;
43652 {
43653 void *ptr;
43654 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43655 _v = 0;
43656 PyErr_Clear();
43657 } else {
43658 _v = 1;
43659 }
43660 }
43661 if (_v) {
43662 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43663 if (_v) {
43664 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43665 }
43666 }
43667 }
43668
43669 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43670 return NULL;
43671 }
43672
43673
43674 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43675 PyObject *resultobj;
43676 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43677 wxWindow *arg2 = (wxWindow *) 0 ;
43678 wxGBSpan *arg3 = 0 ;
43679 bool result;
43680 wxGBSpan temp3 ;
43681 PyObject * obj0 = 0 ;
43682 PyObject * obj1 = 0 ;
43683 PyObject * obj2 = 0 ;
43684
43685 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43687 if (SWIG_arg_fail(1)) SWIG_fail;
43688 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43689 if (SWIG_arg_fail(2)) SWIG_fail;
43690 {
43691 arg3 = &temp3;
43692 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43693 }
43694 {
43695 PyThreadState* __tstate = wxPyBeginAllowThreads();
43696 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43697
43698 wxPyEndAllowThreads(__tstate);
43699 if (PyErr_Occurred()) SWIG_fail;
43700 }
43701 {
43702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43703 }
43704 return resultobj;
43705 fail:
43706 return NULL;
43707 }
43708
43709
43710 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43711 PyObject *resultobj;
43712 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43713 wxSizer *arg2 = (wxSizer *) 0 ;
43714 wxGBSpan *arg3 = 0 ;
43715 bool result;
43716 wxGBSpan temp3 ;
43717 PyObject * obj0 = 0 ;
43718 PyObject * obj1 = 0 ;
43719 PyObject * obj2 = 0 ;
43720
43721 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43723 if (SWIG_arg_fail(1)) SWIG_fail;
43724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43725 if (SWIG_arg_fail(2)) SWIG_fail;
43726 {
43727 arg3 = &temp3;
43728 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43729 }
43730 {
43731 PyThreadState* __tstate = wxPyBeginAllowThreads();
43732 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43733
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 {
43738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43739 }
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43747 PyObject *resultobj;
43748 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43749 size_t arg2 ;
43750 wxGBSpan *arg3 = 0 ;
43751 bool result;
43752 wxGBSpan temp3 ;
43753 PyObject * obj0 = 0 ;
43754 PyObject * obj1 = 0 ;
43755 PyObject * obj2 = 0 ;
43756
43757 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43759 if (SWIG_arg_fail(1)) SWIG_fail;
43760 {
43761 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43762 if (SWIG_arg_fail(2)) SWIG_fail;
43763 }
43764 {
43765 arg3 = &temp3;
43766 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43767 }
43768 {
43769 PyThreadState* __tstate = wxPyBeginAllowThreads();
43770 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43771
43772 wxPyEndAllowThreads(__tstate);
43773 if (PyErr_Occurred()) SWIG_fail;
43774 }
43775 {
43776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43777 }
43778 return resultobj;
43779 fail:
43780 return NULL;
43781 }
43782
43783
43784 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43785 int argc;
43786 PyObject *argv[4];
43787 int ii;
43788
43789 argc = PyObject_Length(args);
43790 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43791 argv[ii] = PyTuple_GetItem(args,ii);
43792 }
43793 if (argc == 3) {
43794 int _v;
43795 {
43796 void *ptr;
43797 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43798 _v = 0;
43799 PyErr_Clear();
43800 } else {
43801 _v = 1;
43802 }
43803 }
43804 if (_v) {
43805 {
43806 void *ptr;
43807 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43808 _v = 0;
43809 PyErr_Clear();
43810 } else {
43811 _v = 1;
43812 }
43813 }
43814 if (_v) {
43815 {
43816 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43817 }
43818 if (_v) {
43819 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43820 }
43821 }
43822 }
43823 }
43824 if (argc == 3) {
43825 int _v;
43826 {
43827 void *ptr;
43828 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43829 _v = 0;
43830 PyErr_Clear();
43831 } else {
43832 _v = 1;
43833 }
43834 }
43835 if (_v) {
43836 {
43837 void *ptr;
43838 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43839 _v = 0;
43840 PyErr_Clear();
43841 } else {
43842 _v = 1;
43843 }
43844 }
43845 if (_v) {
43846 {
43847 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43848 }
43849 if (_v) {
43850 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43851 }
43852 }
43853 }
43854 }
43855 if (argc == 3) {
43856 int _v;
43857 {
43858 void *ptr;
43859 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43860 _v = 0;
43861 PyErr_Clear();
43862 } else {
43863 _v = 1;
43864 }
43865 }
43866 if (_v) {
43867 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43868 if (_v) {
43869 {
43870 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43871 }
43872 if (_v) {
43873 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43874 }
43875 }
43876 }
43877 }
43878
43879 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43880 return NULL;
43881 }
43882
43883
43884 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43885 PyObject *resultobj;
43886 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43887 wxWindow *arg2 = (wxWindow *) 0 ;
43888 wxGBSizerItem *result;
43889 PyObject * obj0 = 0 ;
43890 PyObject * obj1 = 0 ;
43891
43892 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43894 if (SWIG_arg_fail(1)) SWIG_fail;
43895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43896 if (SWIG_arg_fail(2)) SWIG_fail;
43897 {
43898 PyThreadState* __tstate = wxPyBeginAllowThreads();
43899 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43900
43901 wxPyEndAllowThreads(__tstate);
43902 if (PyErr_Occurred()) SWIG_fail;
43903 }
43904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43905 return resultobj;
43906 fail:
43907 return NULL;
43908 }
43909
43910
43911 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43912 PyObject *resultobj;
43913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43914 wxSizer *arg2 = (wxSizer *) 0 ;
43915 wxGBSizerItem *result;
43916 PyObject * obj0 = 0 ;
43917 PyObject * obj1 = 0 ;
43918
43919 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43921 if (SWIG_arg_fail(1)) SWIG_fail;
43922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43923 if (SWIG_arg_fail(2)) SWIG_fail;
43924 {
43925 PyThreadState* __tstate = wxPyBeginAllowThreads();
43926 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43927
43928 wxPyEndAllowThreads(__tstate);
43929 if (PyErr_Occurred()) SWIG_fail;
43930 }
43931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43939 int argc;
43940 PyObject *argv[3];
43941 int ii;
43942
43943 argc = PyObject_Length(args);
43944 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43945 argv[ii] = PyTuple_GetItem(args,ii);
43946 }
43947 if (argc == 2) {
43948 int _v;
43949 {
43950 void *ptr;
43951 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43952 _v = 0;
43953 PyErr_Clear();
43954 } else {
43955 _v = 1;
43956 }
43957 }
43958 if (_v) {
43959 {
43960 void *ptr;
43961 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43962 _v = 0;
43963 PyErr_Clear();
43964 } else {
43965 _v = 1;
43966 }
43967 }
43968 if (_v) {
43969 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43970 }
43971 }
43972 }
43973 if (argc == 2) {
43974 int _v;
43975 {
43976 void *ptr;
43977 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43978 _v = 0;
43979 PyErr_Clear();
43980 } else {
43981 _v = 1;
43982 }
43983 }
43984 if (_v) {
43985 {
43986 void *ptr;
43987 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43988 _v = 0;
43989 PyErr_Clear();
43990 } else {
43991 _v = 1;
43992 }
43993 }
43994 if (_v) {
43995 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43996 }
43997 }
43998 }
43999
44000 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44001 return NULL;
44002 }
44003
44004
44005 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44006 PyObject *resultobj;
44007 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44008 wxGBPosition *arg2 = 0 ;
44009 wxGBSizerItem *result;
44010 wxGBPosition temp2 ;
44011 PyObject * obj0 = 0 ;
44012 PyObject * obj1 = 0 ;
44013 char *kwnames[] = {
44014 (char *) "self",(char *) "pos", NULL
44015 };
44016
44017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44019 if (SWIG_arg_fail(1)) SWIG_fail;
44020 {
44021 arg2 = &temp2;
44022 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44023 }
44024 {
44025 PyThreadState* __tstate = wxPyBeginAllowThreads();
44026 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44027
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44032 return resultobj;
44033 fail:
44034 return NULL;
44035 }
44036
44037
44038 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44039 PyObject *resultobj;
44040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44041 wxPoint *arg2 = 0 ;
44042 wxGBSizerItem *result;
44043 wxPoint temp2 ;
44044 PyObject * obj0 = 0 ;
44045 PyObject * obj1 = 0 ;
44046 char *kwnames[] = {
44047 (char *) "self",(char *) "pt", NULL
44048 };
44049
44050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44052 if (SWIG_arg_fail(1)) SWIG_fail;
44053 {
44054 arg2 = &temp2;
44055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44056 }
44057 {
44058 PyThreadState* __tstate = wxPyBeginAllowThreads();
44059 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44060
44061 wxPyEndAllowThreads(__tstate);
44062 if (PyErr_Occurred()) SWIG_fail;
44063 }
44064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44065 return resultobj;
44066 fail:
44067 return NULL;
44068 }
44069
44070
44071 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44072 PyObject *resultobj;
44073 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44074 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44075 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44076 bool result;
44077 PyObject * obj0 = 0 ;
44078 PyObject * obj1 = 0 ;
44079 PyObject * obj2 = 0 ;
44080 char *kwnames[] = {
44081 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44082 };
44083
44084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44086 if (SWIG_arg_fail(1)) SWIG_fail;
44087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44088 if (SWIG_arg_fail(2)) SWIG_fail;
44089 if (obj2) {
44090 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44091 if (SWIG_arg_fail(3)) SWIG_fail;
44092 }
44093 {
44094 PyThreadState* __tstate = wxPyBeginAllowThreads();
44095 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44096
44097 wxPyEndAllowThreads(__tstate);
44098 if (PyErr_Occurred()) SWIG_fail;
44099 }
44100 {
44101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44102 }
44103 return resultobj;
44104 fail:
44105 return NULL;
44106 }
44107
44108
44109 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44110 PyObject *resultobj;
44111 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44112 wxGBPosition *arg2 = 0 ;
44113 wxGBSpan *arg3 = 0 ;
44114 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44115 bool result;
44116 wxGBPosition temp2 ;
44117 wxGBSpan temp3 ;
44118 PyObject * obj0 = 0 ;
44119 PyObject * obj1 = 0 ;
44120 PyObject * obj2 = 0 ;
44121 PyObject * obj3 = 0 ;
44122 char *kwnames[] = {
44123 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44124 };
44125
44126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44128 if (SWIG_arg_fail(1)) SWIG_fail;
44129 {
44130 arg2 = &temp2;
44131 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44132 }
44133 {
44134 arg3 = &temp3;
44135 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44136 }
44137 if (obj3) {
44138 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44139 if (SWIG_arg_fail(4)) SWIG_fail;
44140 }
44141 {
44142 PyThreadState* __tstate = wxPyBeginAllowThreads();
44143 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44144
44145 wxPyEndAllowThreads(__tstate);
44146 if (PyErr_Occurred()) SWIG_fail;
44147 }
44148 {
44149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44150 }
44151 return resultobj;
44152 fail:
44153 return NULL;
44154 }
44155
44156
44157 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44158 PyObject *obj;
44159 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44160 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44161 Py_INCREF(obj);
44162 return Py_BuildValue((char *)"");
44163 }
44164 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44165 PyObject *resultobj;
44166 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44167 wxRelationship arg2 ;
44168 wxWindow *arg3 = (wxWindow *) 0 ;
44169 wxEdge arg4 ;
44170 int arg5 = (int) 0 ;
44171 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44172 PyObject * obj0 = 0 ;
44173 PyObject * obj1 = 0 ;
44174 PyObject * obj2 = 0 ;
44175 PyObject * obj3 = 0 ;
44176 PyObject * obj4 = 0 ;
44177 PyObject * obj5 = 0 ;
44178 char *kwnames[] = {
44179 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44180 };
44181
44182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44184 if (SWIG_arg_fail(1)) SWIG_fail;
44185 {
44186 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44187 if (SWIG_arg_fail(2)) SWIG_fail;
44188 }
44189 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44190 if (SWIG_arg_fail(3)) SWIG_fail;
44191 {
44192 arg4 = (wxEdge)(SWIG_As_int(obj3));
44193 if (SWIG_arg_fail(4)) SWIG_fail;
44194 }
44195 if (obj4) {
44196 {
44197 arg5 = (int)(SWIG_As_int(obj4));
44198 if (SWIG_arg_fail(5)) SWIG_fail;
44199 }
44200 }
44201 if (obj5) {
44202 {
44203 arg6 = (int)(SWIG_As_int(obj5));
44204 if (SWIG_arg_fail(6)) SWIG_fail;
44205 }
44206 }
44207 {
44208 PyThreadState* __tstate = wxPyBeginAllowThreads();
44209 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44210
44211 wxPyEndAllowThreads(__tstate);
44212 if (PyErr_Occurred()) SWIG_fail;
44213 }
44214 Py_INCREF(Py_None); resultobj = Py_None;
44215 return resultobj;
44216 fail:
44217 return NULL;
44218 }
44219
44220
44221 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44222 PyObject *resultobj;
44223 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44224 wxWindow *arg2 = (wxWindow *) 0 ;
44225 int arg3 = (int) 0 ;
44226 PyObject * obj0 = 0 ;
44227 PyObject * obj1 = 0 ;
44228 PyObject * obj2 = 0 ;
44229 char *kwnames[] = {
44230 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44231 };
44232
44233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44235 if (SWIG_arg_fail(1)) SWIG_fail;
44236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44237 if (SWIG_arg_fail(2)) SWIG_fail;
44238 if (obj2) {
44239 {
44240 arg3 = (int)(SWIG_As_int(obj2));
44241 if (SWIG_arg_fail(3)) SWIG_fail;
44242 }
44243 }
44244 {
44245 PyThreadState* __tstate = wxPyBeginAllowThreads();
44246 (arg1)->LeftOf(arg2,arg3);
44247
44248 wxPyEndAllowThreads(__tstate);
44249 if (PyErr_Occurred()) SWIG_fail;
44250 }
44251 Py_INCREF(Py_None); resultobj = Py_None;
44252 return resultobj;
44253 fail:
44254 return NULL;
44255 }
44256
44257
44258 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44259 PyObject *resultobj;
44260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44261 wxWindow *arg2 = (wxWindow *) 0 ;
44262 int arg3 = (int) 0 ;
44263 PyObject * obj0 = 0 ;
44264 PyObject * obj1 = 0 ;
44265 PyObject * obj2 = 0 ;
44266 char *kwnames[] = {
44267 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44268 };
44269
44270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44272 if (SWIG_arg_fail(1)) SWIG_fail;
44273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44274 if (SWIG_arg_fail(2)) SWIG_fail;
44275 if (obj2) {
44276 {
44277 arg3 = (int)(SWIG_As_int(obj2));
44278 if (SWIG_arg_fail(3)) SWIG_fail;
44279 }
44280 }
44281 {
44282 PyThreadState* __tstate = wxPyBeginAllowThreads();
44283 (arg1)->RightOf(arg2,arg3);
44284
44285 wxPyEndAllowThreads(__tstate);
44286 if (PyErr_Occurred()) SWIG_fail;
44287 }
44288 Py_INCREF(Py_None); resultobj = Py_None;
44289 return resultobj;
44290 fail:
44291 return NULL;
44292 }
44293
44294
44295 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44296 PyObject *resultobj;
44297 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44298 wxWindow *arg2 = (wxWindow *) 0 ;
44299 int arg3 = (int) 0 ;
44300 PyObject * obj0 = 0 ;
44301 PyObject * obj1 = 0 ;
44302 PyObject * obj2 = 0 ;
44303 char *kwnames[] = {
44304 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44305 };
44306
44307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44309 if (SWIG_arg_fail(1)) SWIG_fail;
44310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44311 if (SWIG_arg_fail(2)) SWIG_fail;
44312 if (obj2) {
44313 {
44314 arg3 = (int)(SWIG_As_int(obj2));
44315 if (SWIG_arg_fail(3)) SWIG_fail;
44316 }
44317 }
44318 {
44319 PyThreadState* __tstate = wxPyBeginAllowThreads();
44320 (arg1)->Above(arg2,arg3);
44321
44322 wxPyEndAllowThreads(__tstate);
44323 if (PyErr_Occurred()) SWIG_fail;
44324 }
44325 Py_INCREF(Py_None); resultobj = Py_None;
44326 return resultobj;
44327 fail:
44328 return NULL;
44329 }
44330
44331
44332 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44333 PyObject *resultobj;
44334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44335 wxWindow *arg2 = (wxWindow *) 0 ;
44336 int arg3 = (int) 0 ;
44337 PyObject * obj0 = 0 ;
44338 PyObject * obj1 = 0 ;
44339 PyObject * obj2 = 0 ;
44340 char *kwnames[] = {
44341 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44342 };
44343
44344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44346 if (SWIG_arg_fail(1)) SWIG_fail;
44347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44348 if (SWIG_arg_fail(2)) SWIG_fail;
44349 if (obj2) {
44350 {
44351 arg3 = (int)(SWIG_As_int(obj2));
44352 if (SWIG_arg_fail(3)) SWIG_fail;
44353 }
44354 }
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 (arg1)->Below(arg2,arg3);
44358
44359 wxPyEndAllowThreads(__tstate);
44360 if (PyErr_Occurred()) SWIG_fail;
44361 }
44362 Py_INCREF(Py_None); resultobj = Py_None;
44363 return resultobj;
44364 fail:
44365 return NULL;
44366 }
44367
44368
44369 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44370 PyObject *resultobj;
44371 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44372 wxWindow *arg2 = (wxWindow *) 0 ;
44373 wxEdge arg3 ;
44374 int arg4 = (int) 0 ;
44375 PyObject * obj0 = 0 ;
44376 PyObject * obj1 = 0 ;
44377 PyObject * obj2 = 0 ;
44378 PyObject * obj3 = 0 ;
44379 char *kwnames[] = {
44380 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44381 };
44382
44383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44385 if (SWIG_arg_fail(1)) SWIG_fail;
44386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44387 if (SWIG_arg_fail(2)) SWIG_fail;
44388 {
44389 arg3 = (wxEdge)(SWIG_As_int(obj2));
44390 if (SWIG_arg_fail(3)) SWIG_fail;
44391 }
44392 if (obj3) {
44393 {
44394 arg4 = (int)(SWIG_As_int(obj3));
44395 if (SWIG_arg_fail(4)) SWIG_fail;
44396 }
44397 }
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
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_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44413 PyObject *resultobj;
44414 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44415 wxWindow *arg2 = (wxWindow *) 0 ;
44416 wxEdge arg3 ;
44417 int arg4 ;
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 *) "wh",(char *) "per", NULL
44424 };
44425
44426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",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 {
44436 arg4 = (int)(SWIG_As_int(obj3));
44437 if (SWIG_arg_fail(4)) SWIG_fail;
44438 }
44439 {
44440 PyThreadState* __tstate = wxPyBeginAllowThreads();
44441 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44442
44443 wxPyEndAllowThreads(__tstate);
44444 if (PyErr_Occurred()) SWIG_fail;
44445 }
44446 Py_INCREF(Py_None); resultobj = Py_None;
44447 return resultobj;
44448 fail:
44449 return NULL;
44450 }
44451
44452
44453 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44454 PyObject *resultobj;
44455 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44456 int arg2 ;
44457 PyObject * obj0 = 0 ;
44458 PyObject * obj1 = 0 ;
44459 char *kwnames[] = {
44460 (char *) "self",(char *) "val", NULL
44461 };
44462
44463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44465 if (SWIG_arg_fail(1)) SWIG_fail;
44466 {
44467 arg2 = (int)(SWIG_As_int(obj1));
44468 if (SWIG_arg_fail(2)) SWIG_fail;
44469 }
44470 {
44471 PyThreadState* __tstate = wxPyBeginAllowThreads();
44472 (arg1)->Absolute(arg2);
44473
44474 wxPyEndAllowThreads(__tstate);
44475 if (PyErr_Occurred()) SWIG_fail;
44476 }
44477 Py_INCREF(Py_None); resultobj = Py_None;
44478 return resultobj;
44479 fail:
44480 return NULL;
44481 }
44482
44483
44484 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44485 PyObject *resultobj;
44486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44487 PyObject * obj0 = 0 ;
44488 char *kwnames[] = {
44489 (char *) "self", NULL
44490 };
44491
44492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44494 if (SWIG_arg_fail(1)) SWIG_fail;
44495 {
44496 PyThreadState* __tstate = wxPyBeginAllowThreads();
44497 (arg1)->Unconstrained();
44498
44499 wxPyEndAllowThreads(__tstate);
44500 if (PyErr_Occurred()) SWIG_fail;
44501 }
44502 Py_INCREF(Py_None); resultobj = Py_None;
44503 return resultobj;
44504 fail:
44505 return NULL;
44506 }
44507
44508
44509 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44510 PyObject *resultobj;
44511 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44512 PyObject * obj0 = 0 ;
44513 char *kwnames[] = {
44514 (char *) "self", NULL
44515 };
44516
44517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44519 if (SWIG_arg_fail(1)) SWIG_fail;
44520 {
44521 PyThreadState* __tstate = wxPyBeginAllowThreads();
44522 (arg1)->AsIs();
44523
44524 wxPyEndAllowThreads(__tstate);
44525 if (PyErr_Occurred()) SWIG_fail;
44526 }
44527 Py_INCREF(Py_None); resultobj = Py_None;
44528 return resultobj;
44529 fail:
44530 return NULL;
44531 }
44532
44533
44534 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44535 PyObject *resultobj;
44536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44537 wxWindow *result;
44538 PyObject * obj0 = 0 ;
44539 char *kwnames[] = {
44540 (char *) "self", NULL
44541 };
44542
44543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44545 if (SWIG_arg_fail(1)) SWIG_fail;
44546 {
44547 PyThreadState* __tstate = wxPyBeginAllowThreads();
44548 result = (wxWindow *)(arg1)->GetOtherWindow();
44549
44550 wxPyEndAllowThreads(__tstate);
44551 if (PyErr_Occurred()) SWIG_fail;
44552 }
44553 {
44554 resultobj = wxPyMake_wxObject(result, 0);
44555 }
44556 return resultobj;
44557 fail:
44558 return NULL;
44559 }
44560
44561
44562 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj;
44564 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44565 wxEdge result;
44566 PyObject * obj0 = 0 ;
44567 char *kwnames[] = {
44568 (char *) "self", NULL
44569 };
44570
44571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44573 if (SWIG_arg_fail(1)) SWIG_fail;
44574 {
44575 PyThreadState* __tstate = wxPyBeginAllowThreads();
44576 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44577
44578 wxPyEndAllowThreads(__tstate);
44579 if (PyErr_Occurred()) SWIG_fail;
44580 }
44581 resultobj = SWIG_From_int((result));
44582 return resultobj;
44583 fail:
44584 return NULL;
44585 }
44586
44587
44588 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44589 PyObject *resultobj;
44590 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44591 wxEdge arg2 ;
44592 PyObject * obj0 = 0 ;
44593 PyObject * obj1 = 0 ;
44594 char *kwnames[] = {
44595 (char *) "self",(char *) "which", NULL
44596 };
44597
44598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44600 if (SWIG_arg_fail(1)) SWIG_fail;
44601 {
44602 arg2 = (wxEdge)(SWIG_As_int(obj1));
44603 if (SWIG_arg_fail(2)) SWIG_fail;
44604 }
44605 {
44606 PyThreadState* __tstate = wxPyBeginAllowThreads();
44607 (arg1)->SetEdge((wxEdge )arg2);
44608
44609 wxPyEndAllowThreads(__tstate);
44610 if (PyErr_Occurred()) SWIG_fail;
44611 }
44612 Py_INCREF(Py_None); resultobj = Py_None;
44613 return resultobj;
44614 fail:
44615 return NULL;
44616 }
44617
44618
44619 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44620 PyObject *resultobj;
44621 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44622 int arg2 ;
44623 PyObject * obj0 = 0 ;
44624 PyObject * obj1 = 0 ;
44625 char *kwnames[] = {
44626 (char *) "self",(char *) "v", NULL
44627 };
44628
44629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44631 if (SWIG_arg_fail(1)) SWIG_fail;
44632 {
44633 arg2 = (int)(SWIG_As_int(obj1));
44634 if (SWIG_arg_fail(2)) SWIG_fail;
44635 }
44636 {
44637 PyThreadState* __tstate = wxPyBeginAllowThreads();
44638 (arg1)->SetValue(arg2);
44639
44640 wxPyEndAllowThreads(__tstate);
44641 if (PyErr_Occurred()) SWIG_fail;
44642 }
44643 Py_INCREF(Py_None); resultobj = Py_None;
44644 return resultobj;
44645 fail:
44646 return NULL;
44647 }
44648
44649
44650 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44651 PyObject *resultobj;
44652 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44653 int result;
44654 PyObject * obj0 = 0 ;
44655 char *kwnames[] = {
44656 (char *) "self", NULL
44657 };
44658
44659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44661 if (SWIG_arg_fail(1)) SWIG_fail;
44662 {
44663 PyThreadState* __tstate = wxPyBeginAllowThreads();
44664 result = (int)(arg1)->GetMargin();
44665
44666 wxPyEndAllowThreads(__tstate);
44667 if (PyErr_Occurred()) SWIG_fail;
44668 }
44669 {
44670 resultobj = SWIG_From_int((int)(result));
44671 }
44672 return resultobj;
44673 fail:
44674 return NULL;
44675 }
44676
44677
44678 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44679 PyObject *resultobj;
44680 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44681 int arg2 ;
44682 PyObject * obj0 = 0 ;
44683 PyObject * obj1 = 0 ;
44684 char *kwnames[] = {
44685 (char *) "self",(char *) "m", NULL
44686 };
44687
44688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44690 if (SWIG_arg_fail(1)) SWIG_fail;
44691 {
44692 arg2 = (int)(SWIG_As_int(obj1));
44693 if (SWIG_arg_fail(2)) SWIG_fail;
44694 }
44695 {
44696 PyThreadState* __tstate = wxPyBeginAllowThreads();
44697 (arg1)->SetMargin(arg2);
44698
44699 wxPyEndAllowThreads(__tstate);
44700 if (PyErr_Occurred()) SWIG_fail;
44701 }
44702 Py_INCREF(Py_None); resultobj = Py_None;
44703 return resultobj;
44704 fail:
44705 return NULL;
44706 }
44707
44708
44709 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44710 PyObject *resultobj;
44711 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44712 int result;
44713 PyObject * obj0 = 0 ;
44714 char *kwnames[] = {
44715 (char *) "self", NULL
44716 };
44717
44718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44720 if (SWIG_arg_fail(1)) SWIG_fail;
44721 {
44722 PyThreadState* __tstate = wxPyBeginAllowThreads();
44723 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44724
44725 wxPyEndAllowThreads(__tstate);
44726 if (PyErr_Occurred()) SWIG_fail;
44727 }
44728 {
44729 resultobj = SWIG_From_int((int)(result));
44730 }
44731 return resultobj;
44732 fail:
44733 return NULL;
44734 }
44735
44736
44737 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44738 PyObject *resultobj;
44739 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44740 int result;
44741 PyObject * obj0 = 0 ;
44742 char *kwnames[] = {
44743 (char *) "self", NULL
44744 };
44745
44746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44748 if (SWIG_arg_fail(1)) SWIG_fail;
44749 {
44750 PyThreadState* __tstate = wxPyBeginAllowThreads();
44751 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44752
44753 wxPyEndAllowThreads(__tstate);
44754 if (PyErr_Occurred()) SWIG_fail;
44755 }
44756 {
44757 resultobj = SWIG_From_int((int)(result));
44758 }
44759 return resultobj;
44760 fail:
44761 return NULL;
44762 }
44763
44764
44765 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44766 PyObject *resultobj;
44767 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44768 int result;
44769 PyObject * obj0 = 0 ;
44770 char *kwnames[] = {
44771 (char *) "self", NULL
44772 };
44773
44774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44776 if (SWIG_arg_fail(1)) SWIG_fail;
44777 {
44778 PyThreadState* __tstate = wxPyBeginAllowThreads();
44779 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44780
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 {
44785 resultobj = SWIG_From_int((int)(result));
44786 }
44787 return resultobj;
44788 fail:
44789 return NULL;
44790 }
44791
44792
44793 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44794 PyObject *resultobj;
44795 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44796 bool result;
44797 PyObject * obj0 = 0 ;
44798 char *kwnames[] = {
44799 (char *) "self", NULL
44800 };
44801
44802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44804 if (SWIG_arg_fail(1)) SWIG_fail;
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44808
44809 wxPyEndAllowThreads(__tstate);
44810 if (PyErr_Occurred()) SWIG_fail;
44811 }
44812 {
44813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44814 }
44815 return resultobj;
44816 fail:
44817 return NULL;
44818 }
44819
44820
44821 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44822 PyObject *resultobj;
44823 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44824 bool arg2 ;
44825 PyObject * obj0 = 0 ;
44826 PyObject * obj1 = 0 ;
44827 char *kwnames[] = {
44828 (char *) "self",(char *) "d", NULL
44829 };
44830
44831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44833 if (SWIG_arg_fail(1)) SWIG_fail;
44834 {
44835 arg2 = (bool)(SWIG_As_bool(obj1));
44836 if (SWIG_arg_fail(2)) SWIG_fail;
44837 }
44838 {
44839 PyThreadState* __tstate = wxPyBeginAllowThreads();
44840 (arg1)->SetDone(arg2);
44841
44842 wxPyEndAllowThreads(__tstate);
44843 if (PyErr_Occurred()) SWIG_fail;
44844 }
44845 Py_INCREF(Py_None); resultobj = Py_None;
44846 return resultobj;
44847 fail:
44848 return NULL;
44849 }
44850
44851
44852 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44853 PyObject *resultobj;
44854 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44855 wxRelationship result;
44856 PyObject * obj0 = 0 ;
44857 char *kwnames[] = {
44858 (char *) "self", NULL
44859 };
44860
44861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44863 if (SWIG_arg_fail(1)) SWIG_fail;
44864 {
44865 PyThreadState* __tstate = wxPyBeginAllowThreads();
44866 result = (wxRelationship)(arg1)->GetRelationship();
44867
44868 wxPyEndAllowThreads(__tstate);
44869 if (PyErr_Occurred()) SWIG_fail;
44870 }
44871 resultobj = SWIG_From_int((result));
44872 return resultobj;
44873 fail:
44874 return NULL;
44875 }
44876
44877
44878 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44879 PyObject *resultobj;
44880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44881 wxRelationship arg2 ;
44882 PyObject * obj0 = 0 ;
44883 PyObject * obj1 = 0 ;
44884 char *kwnames[] = {
44885 (char *) "self",(char *) "r", NULL
44886 };
44887
44888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44890 if (SWIG_arg_fail(1)) SWIG_fail;
44891 {
44892 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44893 if (SWIG_arg_fail(2)) SWIG_fail;
44894 }
44895 {
44896 PyThreadState* __tstate = wxPyBeginAllowThreads();
44897 (arg1)->SetRelationship((wxRelationship )arg2);
44898
44899 wxPyEndAllowThreads(__tstate);
44900 if (PyErr_Occurred()) SWIG_fail;
44901 }
44902 Py_INCREF(Py_None); resultobj = Py_None;
44903 return resultobj;
44904 fail:
44905 return NULL;
44906 }
44907
44908
44909 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44910 PyObject *resultobj;
44911 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44912 wxWindow *arg2 = (wxWindow *) 0 ;
44913 bool result;
44914 PyObject * obj0 = 0 ;
44915 PyObject * obj1 = 0 ;
44916 char *kwnames[] = {
44917 (char *) "self",(char *) "otherW", NULL
44918 };
44919
44920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44922 if (SWIG_arg_fail(1)) SWIG_fail;
44923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44924 if (SWIG_arg_fail(2)) SWIG_fail;
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 result = (bool)(arg1)->ResetIfWin(arg2);
44928
44929 wxPyEndAllowThreads(__tstate);
44930 if (PyErr_Occurred()) SWIG_fail;
44931 }
44932 {
44933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44934 }
44935 return resultobj;
44936 fail:
44937 return NULL;
44938 }
44939
44940
44941 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44942 PyObject *resultobj;
44943 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44944 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44945 wxWindow *arg3 = (wxWindow *) 0 ;
44946 bool result;
44947 PyObject * obj0 = 0 ;
44948 PyObject * obj1 = 0 ;
44949 PyObject * obj2 = 0 ;
44950 char *kwnames[] = {
44951 (char *) "self",(char *) "constraints",(char *) "win", NULL
44952 };
44953
44954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44956 if (SWIG_arg_fail(1)) SWIG_fail;
44957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44958 if (SWIG_arg_fail(2)) SWIG_fail;
44959 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44960 if (SWIG_arg_fail(3)) SWIG_fail;
44961 {
44962 PyThreadState* __tstate = wxPyBeginAllowThreads();
44963 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44964
44965 wxPyEndAllowThreads(__tstate);
44966 if (PyErr_Occurred()) SWIG_fail;
44967 }
44968 {
44969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44970 }
44971 return resultobj;
44972 fail:
44973 return NULL;
44974 }
44975
44976
44977 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44978 PyObject *resultobj;
44979 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44980 wxEdge arg2 ;
44981 wxWindow *arg3 = (wxWindow *) 0 ;
44982 wxWindow *arg4 = (wxWindow *) 0 ;
44983 int result;
44984 PyObject * obj0 = 0 ;
44985 PyObject * obj1 = 0 ;
44986 PyObject * obj2 = 0 ;
44987 PyObject * obj3 = 0 ;
44988 char *kwnames[] = {
44989 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44990 };
44991
44992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44994 if (SWIG_arg_fail(1)) SWIG_fail;
44995 {
44996 arg2 = (wxEdge)(SWIG_As_int(obj1));
44997 if (SWIG_arg_fail(2)) SWIG_fail;
44998 }
44999 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45000 if (SWIG_arg_fail(3)) SWIG_fail;
45001 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45002 if (SWIG_arg_fail(4)) SWIG_fail;
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45006
45007 wxPyEndAllowThreads(__tstate);
45008 if (PyErr_Occurred()) SWIG_fail;
45009 }
45010 {
45011 resultobj = SWIG_From_int((int)(result));
45012 }
45013 return resultobj;
45014 fail:
45015 return NULL;
45016 }
45017
45018
45019 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45020 PyObject *obj;
45021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45022 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45023 Py_INCREF(obj);
45024 return Py_BuildValue((char *)"");
45025 }
45026 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45027 PyObject *resultobj;
45028 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45029 wxIndividualLayoutConstraint *result;
45030 PyObject * obj0 = 0 ;
45031 char *kwnames[] = {
45032 (char *) "self", NULL
45033 };
45034
45035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45037 if (SWIG_arg_fail(1)) SWIG_fail;
45038 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45039
45040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45041 return resultobj;
45042 fail:
45043 return NULL;
45044 }
45045
45046
45047 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45048 PyObject *resultobj;
45049 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45050 wxIndividualLayoutConstraint *result;
45051 PyObject * obj0 = 0 ;
45052 char *kwnames[] = {
45053 (char *) "self", NULL
45054 };
45055
45056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45058 if (SWIG_arg_fail(1)) SWIG_fail;
45059 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45060
45061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45062 return resultobj;
45063 fail:
45064 return NULL;
45065 }
45066
45067
45068 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45069 PyObject *resultobj;
45070 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45071 wxIndividualLayoutConstraint *result;
45072 PyObject * obj0 = 0 ;
45073 char *kwnames[] = {
45074 (char *) "self", NULL
45075 };
45076
45077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45079 if (SWIG_arg_fail(1)) SWIG_fail;
45080 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45081
45082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45083 return resultobj;
45084 fail:
45085 return NULL;
45086 }
45087
45088
45089 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45090 PyObject *resultobj;
45091 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45092 wxIndividualLayoutConstraint *result;
45093 PyObject * obj0 = 0 ;
45094 char *kwnames[] = {
45095 (char *) "self", NULL
45096 };
45097
45098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45100 if (SWIG_arg_fail(1)) SWIG_fail;
45101 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45102
45103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45104 return resultobj;
45105 fail:
45106 return NULL;
45107 }
45108
45109
45110 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45111 PyObject *resultobj;
45112 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45113 wxIndividualLayoutConstraint *result;
45114 PyObject * obj0 = 0 ;
45115 char *kwnames[] = {
45116 (char *) "self", NULL
45117 };
45118
45119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45121 if (SWIG_arg_fail(1)) SWIG_fail;
45122 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45123
45124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45125 return resultobj;
45126 fail:
45127 return NULL;
45128 }
45129
45130
45131 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45132 PyObject *resultobj;
45133 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45134 wxIndividualLayoutConstraint *result;
45135 PyObject * obj0 = 0 ;
45136 char *kwnames[] = {
45137 (char *) "self", NULL
45138 };
45139
45140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45142 if (SWIG_arg_fail(1)) SWIG_fail;
45143 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45144
45145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45146 return resultobj;
45147 fail:
45148 return NULL;
45149 }
45150
45151
45152 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45153 PyObject *resultobj;
45154 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45155 wxIndividualLayoutConstraint *result;
45156 PyObject * obj0 = 0 ;
45157 char *kwnames[] = {
45158 (char *) "self", NULL
45159 };
45160
45161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45163 if (SWIG_arg_fail(1)) SWIG_fail;
45164 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45165
45166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45167 return resultobj;
45168 fail:
45169 return NULL;
45170 }
45171
45172
45173 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45174 PyObject *resultobj;
45175 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45176 wxIndividualLayoutConstraint *result;
45177 PyObject * obj0 = 0 ;
45178 char *kwnames[] = {
45179 (char *) "self", NULL
45180 };
45181
45182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45184 if (SWIG_arg_fail(1)) SWIG_fail;
45185 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45186
45187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45188 return resultobj;
45189 fail:
45190 return NULL;
45191 }
45192
45193
45194 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45195 PyObject *resultobj;
45196 wxLayoutConstraints *result;
45197 char *kwnames[] = {
45198 NULL
45199 };
45200
45201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45202 {
45203 PyThreadState* __tstate = wxPyBeginAllowThreads();
45204 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45205
45206 wxPyEndAllowThreads(__tstate);
45207 if (PyErr_Occurred()) SWIG_fail;
45208 }
45209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45210 return resultobj;
45211 fail:
45212 return NULL;
45213 }
45214
45215
45216 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45217 PyObject *resultobj;
45218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45219 wxWindow *arg2 = (wxWindow *) 0 ;
45220 int *arg3 = (int *) 0 ;
45221 bool result;
45222 int temp3 ;
45223 int res3 = 0 ;
45224 PyObject * obj0 = 0 ;
45225 PyObject * obj1 = 0 ;
45226 char *kwnames[] = {
45227 (char *) "self",(char *) "win", NULL
45228 };
45229
45230 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45233 if (SWIG_arg_fail(1)) SWIG_fail;
45234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45235 if (SWIG_arg_fail(2)) SWIG_fail;
45236 {
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45239
45240 wxPyEndAllowThreads(__tstate);
45241 if (PyErr_Occurred()) SWIG_fail;
45242 }
45243 {
45244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45245 }
45246 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45247 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45248 return resultobj;
45249 fail:
45250 return NULL;
45251 }
45252
45253
45254 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45255 PyObject *resultobj;
45256 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45257 bool result;
45258 PyObject * obj0 = 0 ;
45259 char *kwnames[] = {
45260 (char *) "self", NULL
45261 };
45262
45263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45265 if (SWIG_arg_fail(1)) SWIG_fail;
45266 {
45267 PyThreadState* __tstate = wxPyBeginAllowThreads();
45268 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45269
45270 wxPyEndAllowThreads(__tstate);
45271 if (PyErr_Occurred()) SWIG_fail;
45272 }
45273 {
45274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45275 }
45276 return resultobj;
45277 fail:
45278 return NULL;
45279 }
45280
45281
45282 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45283 PyObject *obj;
45284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45285 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45286 Py_INCREF(obj);
45287 return Py_BuildValue((char *)"");
45288 }
45289 static PyMethodDef SwigMethods[] = {
45290 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45291 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45292 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45295 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45316 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45329 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45344 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45398 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45426 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45445 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45447 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45455 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45456 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45468 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45480 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45484 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45490 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45500 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45510 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45517 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45597 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45599 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45601 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45603 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45605 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45607 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45609 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45611 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45613 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45615 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45617 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45619 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45621 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45635 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45653 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45656 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45659 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45671 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45676 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45682 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45688 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45751 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45758 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45794 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45804 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45810 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45812 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45814 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45817 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45821 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45824 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45827 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45829 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45834 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45842 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45846 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45849 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45851 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45855 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45872 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45874 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45877 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45879 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45883 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45887 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45898 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45901 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45904 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45908 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45915 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45920 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45925 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45929 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45974 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45994 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46001 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46005 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46015 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46187 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46227 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46242 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46245 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46300 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46327 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46371 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46379 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46398 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46399 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46436 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46466 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46469 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46473 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46476 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46486 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46498 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46510 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46520 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46530 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46544 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46551 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46552 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46553 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46554 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46555 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46560 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46587 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46599 { NULL, NULL, 0, NULL }
46600 };
46601
46602
46603 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46604
46605 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46606 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46607 }
46608 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46609 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46610 }
46611 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46612 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46613 }
46614 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46615 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46616 }
46617 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46618 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46619 }
46620 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46621 return (void *)((wxSizer *) ((wxGridSizer *) x));
46622 }
46623 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46624 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46625 }
46626 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46627 return (void *)((wxSizer *) ((wxPySizer *) x));
46628 }
46629 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46630 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46631 }
46632 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46633 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46634 }
46635 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46636 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46637 }
46638 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46639 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46640 }
46641 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46642 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46643 }
46644 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46645 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46646 }
46647 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46648 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46649 }
46650 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46651 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46652 }
46653 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46654 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46655 }
46656 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46657 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46658 }
46659 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46660 return (void *)((wxEvent *) ((wxPyEvent *) x));
46661 }
46662 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46663 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46664 }
46665 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46666 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46667 }
46668 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46669 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46670 }
46671 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46672 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46673 }
46674 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46675 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46676 }
46677 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46678 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46679 }
46680 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46681 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46682 }
46683 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46684 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46685 }
46686 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46687 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46688 }
46689 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46690 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46691 }
46692 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46693 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46694 }
46695 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46696 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46697 }
46698 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46699 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46700 }
46701 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46702 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46703 }
46704 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46705 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46706 }
46707 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46708 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46709 }
46710 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46711 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46712 }
46713 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46714 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46715 }
46716 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46717 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46718 }
46719 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46720 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46721 }
46722 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46723 return (void *)((wxEvent *) ((wxShowEvent *) x));
46724 }
46725 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46726 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46727 }
46728 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46729 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46730 }
46731 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46732 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46733 }
46734 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46735 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46736 }
46737 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46738 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46739 }
46740 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46741 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46742 }
46743 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46744 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46745 }
46746 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46747 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46748 }
46749 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46750 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46751 }
46752 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46753 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46754 }
46755 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46756 return (void *)((wxControl *) ((wxControlWithItems *) x));
46757 }
46758 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46759 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46760 }
46761 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46762 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46763 }
46764 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46765 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46766 }
46767 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46768 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46769 }
46770 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46771 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46772 }
46773 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46774 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46775 }
46776 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46777 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46778 }
46779 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46780 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46781 }
46782 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46783 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46784 }
46785 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46786 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46787 }
46788 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46789 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46790 }
46791 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46792 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46793 }
46794 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46795 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46796 }
46797 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46798 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46799 }
46800 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46801 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46802 }
46803 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46804 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46805 }
46806 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46807 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46808 }
46809 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46810 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46811 }
46812 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46813 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46814 }
46815 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46816 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46817 }
46818 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46819 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46820 }
46821 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46822 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46823 }
46824 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46825 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46826 }
46827 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46828 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46829 }
46830 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46831 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46832 }
46833 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46834 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46835 }
46836 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46837 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46838 }
46839 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46840 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46841 }
46842 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46843 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46844 }
46845 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46846 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46847 }
46848 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46849 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46850 }
46851 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46852 return (void *)((wxObject *) ((wxSizerItem *) x));
46853 }
46854 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46855 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46856 }
46857 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46858 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46859 }
46860 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46861 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46862 }
46863 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46864 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46865 }
46866 static void *_p_wxSizerTo_p_wxObject(void *x) {
46867 return (void *)((wxObject *) ((wxSizer *) x));
46868 }
46869 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46870 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46871 }
46872 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46873 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46874 }
46875 static void *_p_wxEventTo_p_wxObject(void *x) {
46876 return (void *)((wxObject *) ((wxEvent *) x));
46877 }
46878 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46879 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46880 }
46881 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46882 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46883 }
46884 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46885 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46886 }
46887 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46888 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46889 }
46890 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46891 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46892 }
46893 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46894 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46895 }
46896 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46897 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46898 }
46899 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46900 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46901 }
46902 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46903 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46904 }
46905 static void *_p_wxControlTo_p_wxObject(void *x) {
46906 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46907 }
46908 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46909 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46910 }
46911 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46912 return (void *)((wxObject *) ((wxFSFile *) x));
46913 }
46914 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46915 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46916 }
46917 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46918 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46919 }
46920 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46921 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46922 }
46923 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46924 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46925 }
46926 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46927 return (void *)((wxObject *) ((wxMenuItem *) x));
46928 }
46929 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46930 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46931 }
46932 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46933 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46934 }
46935 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46936 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46937 }
46938 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46939 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46940 }
46941 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46942 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46943 }
46944 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46945 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46946 }
46947 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46948 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46949 }
46950 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46951 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46952 }
46953 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46954 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46955 }
46956 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46957 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46958 }
46959 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46960 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46961 }
46962 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46963 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46964 }
46965 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46966 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46967 }
46968 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46969 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46970 }
46971 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46972 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46973 }
46974 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46975 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46976 }
46977 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46978 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46979 }
46980 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46981 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46982 }
46983 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46984 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46985 }
46986 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46987 return (void *)((wxObject *) ((wxImageHandler *) x));
46988 }
46989 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46990 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46991 }
46992 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46993 return (void *)((wxObject *) ((wxEvtHandler *) x));
46994 }
46995 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46996 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46997 }
46998 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46999 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47000 }
47001 static void *_p_wxImageTo_p_wxObject(void *x) {
47002 return (void *)((wxObject *) ((wxImage *) x));
47003 }
47004 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47005 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47006 }
47007 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47008 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47009 }
47010 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47011 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47012 }
47013 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47014 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47015 }
47016 static void *_p_wxWindowTo_p_wxObject(void *x) {
47017 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47018 }
47019 static void *_p_wxMenuTo_p_wxObject(void *x) {
47020 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47021 }
47022 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47023 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47024 }
47025 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47026 return (void *)((wxObject *) ((wxFileSystem *) x));
47027 }
47028 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47029 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47030 }
47031 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47032 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47033 }
47034 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47035 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47036 }
47037 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47038 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47039 }
47040 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47041 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47042 }
47043 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47044 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47045 }
47046 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47047 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47048 }
47049 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47050 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47051 }
47052 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47053 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47054 }
47055 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47056 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47057 }
47058 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47059 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47060 }
47061 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47062 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47063 }
47064 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47065 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47066 }
47067 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47068 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47069 }
47070 static void *_p_wxControlTo_p_wxWindow(void *x) {
47071 return (void *)((wxWindow *) ((wxControl *) x));
47072 }
47073 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47074 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47075 }
47076 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47077 return (void *)((wxWindow *) ((wxMenuBar *) x));
47078 }
47079 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47080 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47081 }
47082 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47083 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47084 }
47085 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47086 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47087 }
47088 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47089 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47090 }
47091 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47092 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47093 }
47094 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47095 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47096 }
47097 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47098 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47099 }
47100 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47101 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47102 }
47103 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47104 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47105 }
47106 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47107 return (void *)((wxValidator *) ((wxPyValidator *) x));
47108 }
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 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}};
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237
47238 static swig_type_info *swig_types_initial[] = {
47239 _swigt__p_wxLayoutConstraints,
47240 _swigt__p_wxRealPoint,
47241 _swigt__p_wxSizerItem,
47242 _swigt__p_wxGBSizerItem,
47243 _swigt__p_wxScrollEvent,
47244 _swigt__p_wxEventLoop,
47245 _swigt__p_wxIndividualLayoutConstraint,
47246 _swigt__p_wxSizer,
47247 _swigt__p_wxBoxSizer,
47248 _swigt__p_wxStaticBoxSizer,
47249 _swigt__p_wxGridBagSizer,
47250 _swigt__p_wxAcceleratorEntry,
47251 _swigt__p_wxUpdateUIEvent,
47252 _swigt__p_wxEvent,
47253 _swigt__p_buffer,
47254 _swigt__p_wxMenu,
47255 _swigt__p_wxGridSizer,
47256 _swigt__p_wxFlexGridSizer,
47257 _swigt__p_wxInitDialogEvent,
47258 _swigt__p_wxItemContainer,
47259 _swigt__p_wxNcPaintEvent,
47260 _swigt__p_wxPaintEvent,
47261 _swigt__p_wxSysColourChangedEvent,
47262 _swigt__p_wxMouseCaptureChangedEvent,
47263 _swigt__p_wxDisplayChangedEvent,
47264 _swigt__p_wxPaletteChangedEvent,
47265 _swigt__p_wxControl,
47266 _swigt__p_wxFont,
47267 _swigt__p_wxMenuBarBase,
47268 _swigt__p_wxSetCursorEvent,
47269 _swigt__p_wxFSFile,
47270 _swigt__p_wxCaret,
47271 _swigt__ptrdiff_t,
47272 _swigt__std__ptrdiff_t,
47273 _swigt__p_wxRegion,
47274 _swigt__p_wxPoint2D,
47275 _swigt__p_int,
47276 _swigt__p_wxSize,
47277 _swigt__p_wxDC,
47278 _swigt__p_wxPySizer,
47279 _swigt__p_wxVisualAttributes,
47280 _swigt__p_wxNotifyEvent,
47281 _swigt__p_wxPyEvent,
47282 _swigt__p_wxPropagationDisabler,
47283 _swigt__p_form_ops_t,
47284 _swigt__p_wxAppTraits,
47285 _swigt__p_wxArrayString,
47286 _swigt__p_wxShowEvent,
47287 _swigt__p_wxToolTip,
47288 _swigt__p_wxMoveEvent,
47289 _swigt__p_wxSizeEvent,
47290 _swigt__p_wxActivateEvent,
47291 _swigt__p_wxIconizeEvent,
47292 _swigt__p_wxMaximizeEvent,
47293 _swigt__p_wxQueryNewPaletteEvent,
47294 _swigt__p_wxWindowCreateEvent,
47295 _swigt__p_wxIdleEvent,
47296 _swigt__p_wxDateEvent,
47297 _swigt__p_wxMenuItem,
47298 _swigt__p_wxStaticBox,
47299 _swigt__p_long,
47300 _swigt__p_wxDuplexMode,
47301 _swigt__p_wxTIFFHandler,
47302 _swigt__p_wxXPMHandler,
47303 _swigt__p_wxPNMHandler,
47304 _swigt__p_wxJPEGHandler,
47305 _swigt__p_wxPCXHandler,
47306 _swigt__p_wxGIFHandler,
47307 _swigt__p_wxPNGHandler,
47308 _swigt__p_wxANIHandler,
47309 _swigt__p_wxMemoryFSHandler,
47310 _swigt__p_wxZipFSHandler,
47311 _swigt__p_wxInternetFSHandler,
47312 _swigt__p_wxPyFileSystemHandler,
47313 _swigt__p_wxEvtHandler,
47314 _swigt__p_wxCURHandler,
47315 _swigt__p_wxICOHandler,
47316 _swigt__p_wxBMPHandler,
47317 _swigt__p_wxImageHandler,
47318 _swigt__p_wxFileSystemHandler,
47319 _swigt__p_wxRect,
47320 _swigt__p_wxButton,
47321 _swigt__p_wxGBSpan,
47322 _swigt__p_wxPropagateOnce,
47323 _swigt__p_wxAcceleratorTable,
47324 _swigt__p_wxStdDialogButtonSizer,
47325 _swigt__p_char,
47326 _swigt__p_wxGBPosition,
47327 _swigt__p_wxImage,
47328 _swigt__p_wxFrame,
47329 _swigt__p_wxScrollWinEvent,
47330 _swigt__p_wxPaperSize,
47331 _swigt__p_wxImageHistogram,
47332 _swigt__p_wxPoint,
47333 _swigt__p_wxCursor,
47334 _swigt__p_wxObject,
47335 _swigt__p_wxInputStream,
47336 _swigt__p_wxOutputStream,
47337 _swigt__p_wxPyInputStream,
47338 _swigt__p_wxDateTime,
47339 _swigt__p_wxKeyEvent,
47340 _swigt__p_wxNavigationKeyEvent,
47341 _swigt__p_wxWindowDestroyEvent,
47342 _swigt__p_unsigned_long,
47343 _swigt__p_wxWindow,
47344 _swigt__p_wxMenuBar,
47345 _swigt__p_wxFileSystem,
47346 _swigt__p_wxBitmap,
47347 _swigt__unsigned_int,
47348 _swigt__p_unsigned_int,
47349 _swigt__p_wxMenuEvent,
47350 _swigt__p_wxContextMenuEvent,
47351 _swigt__p_unsigned_char,
47352 _swigt__p_wxEraseEvent,
47353 _swigt__p_wxMouseEvent,
47354 _swigt__p_wxCloseEvent,
47355 _swigt__p_wxPyApp,
47356 _swigt__p_wxCommandEvent,
47357 _swigt__p_wxPyCommandEvent,
47358 _swigt__p_wxPyDropTarget,
47359 _swigt__p_wxQuantize,
47360 _swigt__p_wxFocusEvent,
47361 _swigt__p_wxChildFocusEvent,
47362 _swigt__p_wxDropFilesEvent,
47363 _swigt__p_wxControlWithItems,
47364 _swigt__p_wxColour,
47365 _swigt__p_wxValidator,
47366 _swigt__p_wxPyValidator,
47367 0
47368 };
47369
47370
47371 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47372
47373 static swig_const_info swig_const_table[] = {
47374 {0, 0, 0, 0.0, 0, 0}};
47375
47376 #ifdef __cplusplus
47377 }
47378 #endif
47379
47380
47381 #ifdef __cplusplus
47382 extern "C" {
47383 #endif
47384
47385 /* Python-specific SWIG API */
47386 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47387 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47388 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47389
47390 /* -----------------------------------------------------------------------------
47391 * global variable support code.
47392 * ----------------------------------------------------------------------------- */
47393
47394 typedef struct swig_globalvar {
47395 char *name; /* Name of global variable */
47396 PyObject *(*get_attr)(); /* Return the current value */
47397 int (*set_attr)(PyObject *); /* Set the value */
47398 struct swig_globalvar *next;
47399 } swig_globalvar;
47400
47401 typedef struct swig_varlinkobject {
47402 PyObject_HEAD
47403 swig_globalvar *vars;
47404 } swig_varlinkobject;
47405
47406 static PyObject *
47407 swig_varlink_repr(swig_varlinkobject *v) {
47408 v = v;
47409 return PyString_FromString("<Swig global variables>");
47410 }
47411
47412 static int
47413 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47414 swig_globalvar *var;
47415 flags = flags;
47416 fprintf(fp,"Swig global variables { ");
47417 for (var = v->vars; var; var=var->next) {
47418 fprintf(fp,"%s", var->name);
47419 if (var->next) fprintf(fp,", ");
47420 }
47421 fprintf(fp," }\n");
47422 return 0;
47423 }
47424
47425 static PyObject *
47426 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47427 swig_globalvar *var = v->vars;
47428 while (var) {
47429 if (strcmp(var->name,n) == 0) {
47430 return (*var->get_attr)();
47431 }
47432 var = var->next;
47433 }
47434 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47435 return NULL;
47436 }
47437
47438 static int
47439 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47440 swig_globalvar *var = v->vars;
47441 while (var) {
47442 if (strcmp(var->name,n) == 0) {
47443 return (*var->set_attr)(p);
47444 }
47445 var = var->next;
47446 }
47447 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47448 return 1;
47449 }
47450
47451 static PyTypeObject varlinktype = {
47452 PyObject_HEAD_INIT(0)
47453 0, /* Number of items in variable part (ob_size) */
47454 (char *)"swigvarlink", /* Type name (tp_name) */
47455 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47456 0, /* Itemsize (tp_itemsize) */
47457 0, /* Deallocator (tp_dealloc) */
47458 (printfunc) swig_varlink_print, /* Print (tp_print) */
47459 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47460 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47461 0, /* tp_compare */
47462 (reprfunc) swig_varlink_repr, /* tp_repr */
47463 0, /* tp_as_number */
47464 0, /* tp_as_sequence */
47465 0, /* tp_as_mapping */
47466 0, /* tp_hash */
47467 0, /* tp_call */
47468 0, /* tp_str */
47469 0, /* tp_getattro */
47470 0, /* tp_setattro */
47471 0, /* tp_as_buffer */
47472 0, /* tp_flags */
47473 0, /* tp_doc */
47474 #if PY_VERSION_HEX >= 0x02000000
47475 0, /* tp_traverse */
47476 0, /* tp_clear */
47477 #endif
47478 #if PY_VERSION_HEX >= 0x02010000
47479 0, /* tp_richcompare */
47480 0, /* tp_weaklistoffset */
47481 #endif
47482 #if PY_VERSION_HEX >= 0x02020000
47483 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47484 #endif
47485 #if PY_VERSION_HEX >= 0x02030000
47486 0, /* tp_del */
47487 #endif
47488 #ifdef COUNT_ALLOCS
47489 0,0,0,0 /* tp_alloc -> tp_next */
47490 #endif
47491 };
47492
47493 /* Create a variable linking object for use later */
47494 static PyObject *
47495 SWIG_Python_newvarlink(void) {
47496 swig_varlinkobject *result = 0;
47497 result = PyMem_NEW(swig_varlinkobject,1);
47498 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47499 result->ob_type = &varlinktype;
47500 result->vars = 0;
47501 result->ob_refcnt = 0;
47502 Py_XINCREF((PyObject *) result);
47503 return ((PyObject*) result);
47504 }
47505
47506 static void
47507 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47508 swig_varlinkobject *v;
47509 swig_globalvar *gv;
47510 v= (swig_varlinkobject *) p;
47511 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47512 gv->name = (char *) malloc(strlen(name)+1);
47513 strcpy(gv->name,name);
47514 gv->get_attr = get_attr;
47515 gv->set_attr = set_attr;
47516 gv->next = v->vars;
47517 v->vars = gv;
47518 }
47519
47520 /* -----------------------------------------------------------------------------
47521 * constants/methods manipulation
47522 * ----------------------------------------------------------------------------- */
47523
47524 /* Install Constants */
47525 static void
47526 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47527 PyObject *obj = 0;
47528 size_t i;
47529 for (i = 0; constants[i].type; i++) {
47530 switch(constants[i].type) {
47531 case SWIG_PY_INT:
47532 obj = PyInt_FromLong(constants[i].lvalue);
47533 break;
47534 case SWIG_PY_FLOAT:
47535 obj = PyFloat_FromDouble(constants[i].dvalue);
47536 break;
47537 case SWIG_PY_STRING:
47538 if (constants[i].pvalue) {
47539 obj = PyString_FromString((char *) constants[i].pvalue);
47540 } else {
47541 Py_INCREF(Py_None);
47542 obj = Py_None;
47543 }
47544 break;
47545 case SWIG_PY_POINTER:
47546 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47547 break;
47548 case SWIG_PY_BINARY:
47549 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47550 break;
47551 default:
47552 obj = 0;
47553 break;
47554 }
47555 if (obj) {
47556 PyDict_SetItemString(d,constants[i].name,obj);
47557 Py_DECREF(obj);
47558 }
47559 }
47560 }
47561
47562 /* -----------------------------------------------------------------------------*/
47563 /* Fix SwigMethods to carry the callback ptrs when needed */
47564 /* -----------------------------------------------------------------------------*/
47565
47566 static void
47567 SWIG_Python_FixMethods(PyMethodDef *methods,
47568 swig_const_info *const_table,
47569 swig_type_info **types,
47570 swig_type_info **types_initial) {
47571 size_t i;
47572 for (i = 0; methods[i].ml_name; ++i) {
47573 char *c = methods[i].ml_doc;
47574 if (c && (c = strstr(c, "swig_ptr: "))) {
47575 int j;
47576 swig_const_info *ci = 0;
47577 char *name = c + 10;
47578 for (j = 0; const_table[j].type; j++) {
47579 if (strncmp(const_table[j].name, name,
47580 strlen(const_table[j].name)) == 0) {
47581 ci = &(const_table[j]);
47582 break;
47583 }
47584 }
47585 if (ci) {
47586 size_t shift = (ci->ptype) - types;
47587 swig_type_info *ty = types_initial[shift];
47588 size_t ldoc = (c - methods[i].ml_doc);
47589 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47590 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47591 char *buff = ndoc;
47592 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47593 strncpy(buff, methods[i].ml_doc, ldoc);
47594 buff += ldoc;
47595 strncpy(buff, "swig_ptr: ", 10);
47596 buff += 10;
47597 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47598 methods[i].ml_doc = ndoc;
47599 }
47600 }
47601 }
47602 }
47603
47604 /* -----------------------------------------------------------------------------*
47605 * Initialize type list
47606 * -----------------------------------------------------------------------------*/
47607
47608 #if PY_MAJOR_VERSION < 2
47609 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47610 is copied out of Python/modsupport.c in python version 2.3.4 */
47611 static int
47612 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47613 {
47614 PyObject *dict;
47615 if (!PyModule_Check(m)) {
47616 PyErr_SetString(PyExc_TypeError,
47617 "PyModule_AddObject() needs module as first arg");
47618 return -1;
47619 }
47620 if (!o) {
47621 PyErr_SetString(PyExc_TypeError,
47622 "PyModule_AddObject() needs non-NULL value");
47623 return -1;
47624 }
47625
47626 dict = PyModule_GetDict(m);
47627 if (dict == NULL) {
47628 /* Internal error -- modules must have a dict! */
47629 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47630 PyModule_GetName(m));
47631 return -1;
47632 }
47633 if (PyDict_SetItemString(dict, name, o))
47634 return -1;
47635 Py_DECREF(o);
47636 return 0;
47637 }
47638 #endif
47639
47640 static swig_type_info **
47641 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47642 static PyMethodDef swig_empty_runtime_method_table[] = {
47643 {
47644 NULL, NULL, 0, NULL
47645 }
47646 };/* Sentinel */
47647
47648 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47649 swig_empty_runtime_method_table);
47650 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47651 if (pointer && module) {
47652 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47653 }
47654 return type_list_handle;
47655 }
47656
47657 static swig_type_info **
47658 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47659 swig_type_info **type_pointer;
47660
47661 /* first check if module already created */
47662 type_pointer = SWIG_Python_GetTypeListHandle();
47663 if (type_pointer) {
47664 return type_pointer;
47665 } else {
47666 /* create a new module and variable */
47667 return SWIG_Python_SetTypeListHandle(type_list_handle);
47668 }
47669 }
47670
47671 #ifdef __cplusplus
47672 }
47673 #endif
47674
47675 /* -----------------------------------------------------------------------------*
47676 * Partial Init method
47677 * -----------------------------------------------------------------------------*/
47678
47679 #ifdef SWIG_LINK_RUNTIME
47680 #ifdef __cplusplus
47681 extern "C"
47682 #endif
47683 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47684 #endif
47685
47686 #ifdef __cplusplus
47687 extern "C"
47688 #endif
47689 SWIGEXPORT(void) SWIG_init(void) {
47690 static PyObject *SWIG_globals = 0;
47691 static int typeinit = 0;
47692 PyObject *m, *d;
47693 int i;
47694 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47695
47696 /* Fix SwigMethods to carry the callback ptrs when needed */
47697 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47698
47699 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47700 d = PyModule_GetDict(m);
47701
47702 if (!typeinit) {
47703 #ifdef SWIG_LINK_RUNTIME
47704 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47705 #else
47706 # ifndef SWIG_STATIC_RUNTIME
47707 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47708 # endif
47709 #endif
47710 for (i = 0; swig_types_initial[i]; i++) {
47711 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47712 }
47713 typeinit = 1;
47714 }
47715 SWIG_InstallConstants(d,swig_const_table);
47716
47717
47718 #ifndef wxPyUSE_EXPORT
47719 // Make our API structure a CObject so other modules can import it
47720 // from this module.
47721 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47722 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47723 Py_XDECREF(cobj);
47724 #endif
47725
47726 {
47727 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49384 }
49385 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49386 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49387 {
49388 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49539 }
49540 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49541 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49542 {
49543 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49550 }
49551
49552 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49553
49554
49555 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49556
49557 {
49558 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49565 }
49566 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49567 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49568 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49569 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49570 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49571 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49572 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49573 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49574 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49575 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49576 {
49577 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49581 }
49582 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49583 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49584 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49585 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49586 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49587 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49588 {
49589 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49635 }
49636 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49637 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49638 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49639 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49640 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49641 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49642 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49643 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49644 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49645 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49646 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49647 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49648 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49649 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49650 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49651 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49652 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49653 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49654 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49655 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49656 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49657 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49658 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49659 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49660 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49661 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49662 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49663 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49664 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49665 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49666 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49667 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49668 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49669 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49670 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49671 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49672 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49673 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49674 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49675 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49676 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49677 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49678 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49679 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49680 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49681 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49682 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49683 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49684 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49685 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49686 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49687 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49688 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49689 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49690 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49691 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49692 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49693 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49694 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49695 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49696 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49697 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49698 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49699 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49700 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49701 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49702 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49703 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49704 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49705 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49706 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49707 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49708 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49709 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49710 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49711 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49712 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49713 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49714 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49715 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49716 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49717 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49718 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49719 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49720 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49721 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49722 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49723 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49724 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49725 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49726 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49727 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49728 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49729 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49730 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49731 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49732 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49733 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49734 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49735 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49736 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49737 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49738 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49739 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49740 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49741 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49742 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49743 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49744 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49745 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49746 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49747 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49748 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49749 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49750 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49751 {
49752 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49789 }
49790 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49791 {
49792 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49793 }
49794 {
49795 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49796 }
49797 {
49798 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49808 }
49809 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49810 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49811 {
49812 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49825 }
49826 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49827 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49828 {
49829 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49836 }
49837 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49838 {
49839 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49840 }
49841 {
49842 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49873 }
49874 {
49875 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49894 }
49895
49896 // Initialize threading, some globals and such
49897 __wxPyPreStart(d);
49898
49899
49900 // Although these are defined in __version__ they need to be here too so
49901 // that an assert can be done to ensure that the wxPython and the wxWindows
49902 // versions match.
49903 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49904 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49905 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49906
49907 }
49908
wxWidgets (Impactor)