]> 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
Added wx.Rect.IsEmpty
[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 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 bool blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 bool blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 bool blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 bool blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 bool blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 bool blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 bool blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2305 if (width > 0 && height > 0)
2306 return new wxImage(width, height, clear);
2307 else
2308 return new wxImage;
2309 }
2310 static wxImage *new_wxImage(wxBitmap const &bitmap){
2311 return new wxImage(bitmap.ConvertToImage());
2312 }
2313 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2314 // Copy the source data so the wxImage can clean it up later
2315 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2316 if (copy == NULL) {
2317 PyErr_NoMemory();
2318 return NULL;
2319 }
2320 memcpy(copy, data, width*height*3);
2321 return new wxImage(width, height, copy, false);
2322 }
2323 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2324 // Copy the source data so the wxImage can clean it up later
2325 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2326 if (dcopy == NULL) {
2327 PyErr_NoMemory();
2328 return NULL;
2329 }
2330 memcpy(dcopy, data, width*height*3);
2331 unsigned char* acopy = (unsigned char*)malloc(width*height);
2332 if (acopy == NULL) {
2333 PyErr_NoMemory();
2334 return NULL;
2335 }
2336 memcpy(acopy, alpha, width*height);
2337
2338 return new wxImage(width, height, dcopy, acopy, false);
2339 }
2340 static wxSize wxImage_GetSize(wxImage *self){
2341 wxSize size(self->GetWidth(), self->GetHeight());
2342 return size;
2343 }
2344 static PyObject *wxImage_GetData(wxImage *self){
2345 unsigned char* data = self->GetData();
2346 int len = self->GetWidth() * self->GetHeight() * 3;
2347 PyObject* rv;
2348 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2349 return rv;
2350 }
2351 static void wxImage_SetData(wxImage *self,PyObject *data){
2352 unsigned char* dataPtr;
2353
2354 if (! PyString_Check(data)) {
2355 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2356 "Expected string object"));
2357 return /* NULL */ ;
2358 }
2359
2360 size_t len = self->GetWidth() * self->GetHeight() * 3;
2361 dataPtr = (unsigned char*) malloc(len);
2362 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2363 self->SetData(dataPtr);
2364 // wxImage takes ownership of dataPtr...
2365 }
2366 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2367 unsigned char* data = self->GetData();
2368 int len = self->GetWidth() * self->GetHeight() * 3;
2369 PyObject* rv;
2370 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2371 return rv;
2372 }
2373 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2374 unsigned char* buffer;
2375 int size;
2376
2377 bool blocked = wxPyBeginBlockThreads();
2378 if (!PyArg_Parse(data, "t#", &buffer, &size))
2379 goto done;
2380
2381 if (size != self->GetWidth() * self->GetHeight() * 3) {
2382 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2383 goto done;
2384 }
2385 self->SetData(buffer);
2386 done:
2387 wxPyEndBlockThreads(blocked);
2388 }
2389 static PyObject *wxImage_GetAlphaData(wxImage *self){
2390 unsigned char* data = self->GetAlpha();
2391 if (! data) {
2392 RETURN_NONE();
2393 } else {
2394 int len = self->GetWidth() * self->GetHeight();
2395 PyObject* rv;
2396 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2397 return rv;
2398 }
2399 }
2400 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2401 unsigned char* dataPtr;
2402
2403 if (! PyString_Check(data)) {
2404 PyErr_SetString(PyExc_TypeError, "Expected string object");
2405 return /* NULL */ ;
2406 }
2407
2408 size_t len = self->GetWidth() * self->GetHeight();
2409 dataPtr = (unsigned char*) malloc(len);
2410 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2411 self->SetAlpha(dataPtr);
2412 // wxImage takes ownership of dataPtr...
2413 }
2414 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2415 unsigned char* data = self->GetAlpha();
2416 int len = self->GetWidth() * self->GetHeight();
2417 PyObject* rv;
2418 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2419 return rv;
2420 }
2421 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2422 unsigned char* buffer;
2423 int size;
2424
2425 bool blocked = wxPyBeginBlockThreads();
2426 if (!PyArg_Parse(data, "t#", &buffer, &size))
2427 goto done;
2428
2429 if (size != self->GetWidth() * self->GetHeight()) {
2430 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2431 goto done;
2432 }
2433 self->SetAlpha(buffer);
2434 done:
2435 wxPyEndBlockThreads(blocked);
2436 }
2437
2438 SWIGINTERNSHORT unsigned long
2439 SWIG_As_unsigned_SS_long(PyObject* obj)
2440 {
2441 unsigned long v;
2442 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2443 /*
2444 this is needed to make valgrind/purify happier.
2445 */
2446 memset((void*)&v, 0, sizeof(unsigned long));
2447 }
2448 return v;
2449 }
2450
2451
2452 SWIGINTERNSHORT int
2453 SWIG_Check_unsigned_SS_long(PyObject* obj)
2454 {
2455 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2456 }
2457
2458 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2459 wxBitmap bitmap(*self, depth);
2460 return bitmap;
2461 }
2462 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2463 wxImage mono = self->ConvertToMono( red, green, blue );
2464 wxBitmap bitmap( mono, 1 );
2465 return bitmap;
2466 }
2467 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2468 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2470 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2474 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2475 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2476 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2477 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2478 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2479 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2480 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2481 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2482
2483 #include <wx/quantize.h>
2484
2485 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2486 return wxQuantize::Quantize(src, dest,
2487 //NULL, // palette
2488 desiredNoColours,
2489 NULL, // eightBitData
2490 flags);
2491 }
2492 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2493 if (PyCallable_Check(func)) {
2494 self->Connect(id, lastId, eventType,
2495 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2496 new wxPyCallback(func));
2497 }
2498 else if (func == Py_None) {
2499 self->Disconnect(id, lastId, eventType,
2500 (wxObjectEventFunction)
2501 &wxPyCallback::EventThunker);
2502 }
2503 else {
2504 wxPyBLOCK_THREADS(
2505 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2506 }
2507 }
2508 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2509 return self->Disconnect(id, lastId, eventType,
2510 (wxObjectEventFunction)
2511 &wxPyCallback::EventThunker);
2512 }
2513 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2514 if (_self && _self != Py_None) {
2515 self->SetClientObject(new wxPyOORClientData(_self, incref));
2516 }
2517 else {
2518 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2519 if (data) {
2520 self->SetClientObject(NULL); // This will delete it too
2521 }
2522 }
2523 }
2524
2525 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2526 #if wxUSE_UNICODE
2527 return self->GetUnicodeKey();
2528 #else
2529 return 0;
2530 #endif
2531 }
2532
2533 #if UINT_MAX < LONG_MAX
2534 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_long
2536 /*@@*/
2537 #else
2538 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2539 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2540 /*@@*/
2541 #endif
2542
2543
2544 #if UINT_MAX != ULONG_MAX
2545 SWIGINTERN int
2546 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2547 {
2548 const char* errmsg = val ? "unsigned int" : (char*)0;
2549 unsigned long v;
2550 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2551 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2552 if (val) *val = (unsigned int)(v);
2553 return 1;
2554 }
2555 } else {
2556 PyErr_Clear();
2557 }
2558 if (val) {
2559 SWIG_type_error(errmsg, obj);
2560 }
2561 return 0;
2562 }
2563 #else
2564 SWIGINTERNSHORT unsigned int
2565 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2566 {
2567 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2568 }
2569 #endif
2570
2571
2572 SWIGINTERNSHORT unsigned int
2573 SWIG_As_unsigned_SS_int(PyObject* obj)
2574 {
2575 unsigned int v;
2576 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2577 /*
2578 this is needed to make valgrind/purify happier.
2579 */
2580 memset((void*)&v, 0, sizeof(unsigned int));
2581 }
2582 return v;
2583 }
2584
2585
2586 SWIGINTERNSHORT int
2587 SWIG_Check_unsigned_SS_int(PyObject* obj)
2588 {
2589 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2590 }
2591
2592 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2593 self->m_size = size;
2594 }
2595 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2596 int count = self->GetNumberOfFiles();
2597 wxString* files = self->GetFiles();
2598 PyObject* list = PyList_New(count);
2599
2600 if (!list) {
2601 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2602 return NULL;
2603 }
2604
2605 for (int i=0; i<count; i++) {
2606 PyList_SetItem(list, i, wx2PyString(files[i]));
2607 }
2608 return list;
2609 }
2610
2611
2612 static wxPyApp *new_wxPyApp(){
2613 wxPythonApp = new wxPyApp();
2614 return wxPythonApp;
2615 }
2616 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2617
2618 void wxApp_CleanUp() {
2619 __wxPyCleanup();
2620 }
2621
2622
2623 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2624
2625
2626 SWIGINTERNSHORT int
2627 SWIG_AsCharPtr(PyObject *obj, char **val)
2628 {
2629 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2630 return 1;
2631 }
2632 if (val) {
2633 PyErr_Clear();
2634 SWIG_type_error("char *", obj);
2635 }
2636 return 0;
2637 }
2638
2639
2640 SWIGINTERN PyObject *
2641 SWIG_FromCharPtr(const char* cptr)
2642 {
2643 if (cptr) {
2644 size_t size = strlen(cptr);
2645 if (size > INT_MAX) {
2646 return SWIG_NewPointerObj((char*)(cptr),
2647 SWIG_TypeQuery("char *"), 0);
2648 } else {
2649 if (size != 0) {
2650 return PyString_FromStringAndSize(cptr, size);
2651 } else {
2652 return PyString_FromString(cptr);
2653 }
2654 }
2655 }
2656 Py_INCREF(Py_None);
2657 return Py_None;
2658 }
2659
2660
2661 #ifdef __WXMAC__
2662
2663 // A dummy class that raises an exception if used...
2664 class wxEventLoop
2665 {
2666 public:
2667 wxEventLoop() { wxPyRaiseNotImplemented(); }
2668 int Run() { return 0; }
2669 void Exit(int rc = 0) {}
2670 bool Pending() const { return false; }
2671 bool Dispatch() { return false; }
2672 bool IsRunning() const { return false; }
2673 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2674 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2675 };
2676
2677 #else
2678
2679 #include <wx/evtloop.h>
2680
2681 #endif
2682
2683
2684
2685 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2686 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2687 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2688 static PyObject *wxWindow_GetChildren(wxWindow *self){
2689 wxWindowList& list = self->GetChildren();
2690 return wxPy_ConvertList(&list);
2691 }
2692 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2693 #if wxUSE_HOTKEY
2694 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2695 #else
2696 return false;
2697 #endif
2698 }
2699 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2700
2701
2702
2703 return false;
2704
2705 }
2706 static long wxWindow_GetHandle(wxWindow *self){
2707 return wxPyGetWinHandle(self);
2708 }
2709 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2710 self->AssociateHandle((WXWidget)handle);
2711 }
2712
2713 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2714 return wxWindow::FindWindowById(id, parent);
2715 }
2716
2717 wxWindow* wxFindWindowByName( const wxString& name,
2718 const wxWindow *parent = NULL ) {
2719 return wxWindow::FindWindowByName(name, parent);
2720 }
2721
2722 wxWindow* wxFindWindowByLabel( const wxString& label,
2723 const wxWindow *parent = NULL ) {
2724 return wxWindow::FindWindowByLabel(label, parent);
2725 }
2726
2727
2728 #ifdef __WXMSW__
2729 #include <wx/msw/private.h> // to get wxGetWindowId
2730 #endif
2731
2732
2733 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2734 #ifdef __WXMSW__
2735 WXHWND hWnd = (WXHWND)_hWnd;
2736 long id = wxGetWindowId(hWnd);
2737 wxWindow* win = new wxWindow;
2738 parent->AddChild(win);
2739 win->SetEventHandler(win);
2740 win->SetHWND(hWnd);
2741 win->SetId(id);
2742 win->SubclassWin(hWnd);
2743 win->AdoptAttributesFromHWND();
2744 win->SetupColours();
2745 return win;
2746 #else
2747 wxPyRaiseNotImplemented();
2748 return NULL;
2749 #endif
2750 }
2751
2752
2753 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2755 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2756
2757 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2758
2759 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2760 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2761 wxMenuItemList& list = self->GetMenuItems();
2762 return wxPy_ConvertList(&list);
2763 }
2764 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2765 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2766 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2767 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2768 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2769 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2770 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2771 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2772 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2773 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2774 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2775 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2776 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2777 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2778 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2779 static const wxString wxPyControlNameStr(wxControlNameStr);
2780 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2781 if (clientData) {
2782 wxPyClientData* data = new wxPyClientData(clientData);
2783 return self->Append(item, data);
2784 } else
2785 return self->Append(item);
2786 }
2787 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2788 if (clientData) {
2789 wxPyClientData* data = new wxPyClientData(clientData);
2790 return self->Insert(item, pos, data);
2791 } else
2792 return self->Insert(item, pos);
2793 }
2794 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2795 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2796 if (data) {
2797 Py_INCREF(data->m_obj);
2798 return data->m_obj;
2799 } else {
2800 Py_INCREF(Py_None);
2801 return Py_None;
2802 }
2803 }
2804 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 self->SetClientObject(n, data);
2807 }
2808
2809
2810 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2811 wxPyUserData* data = NULL;
2812 if ( userData ) {
2813 bool blocked = wxPyBeginBlockThreads();
2814 data = new wxPyUserData(userData);
2815 wxPyEndBlockThreads(blocked);
2816 }
2817 return new wxSizerItem(window, proportion, flag, border, data);
2818 }
2819 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2820 wxPyUserData* data = NULL;
2821 if ( userData ) {
2822 bool blocked = wxPyBeginBlockThreads();
2823 data = new wxPyUserData(userData);
2824 wxPyEndBlockThreads(blocked);
2825 }
2826 return new wxSizerItem(width, height, proportion, flag, border, data);
2827 }
2828 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2829 wxPyUserData* data = NULL;
2830 if ( userData ) {
2831 bool blocked = wxPyBeginBlockThreads();
2832 data = new wxPyUserData(userData);
2833 wxPyEndBlockThreads(blocked);
2834 }
2835 return new wxSizerItem(sizer, proportion, flag, border, data);
2836 }
2837
2838 #include <float.h>
2839 SWIGINTERN int
2840 SWIG_CheckDoubleInRange(double value, double min_value,
2841 double max_value, const char* errmsg)
2842 {
2843 if (value < min_value) {
2844 if (errmsg) {
2845 PyErr_Format(PyExc_OverflowError,
2846 "value %g is less than %s minimum %g",
2847 value, errmsg, min_value);
2848 }
2849 return 0;
2850 } else if (value > max_value) {
2851 if (errmsg) {
2852 PyErr_Format(PyExc_OverflowError,
2853 "value %g is greater than %s maximum %g",
2854 value, errmsg, max_value);
2855 }
2856 return 0;
2857 }
2858 return 1;
2859 }
2860
2861
2862 SWIGINTERN int
2863 SWIG_AsVal_float(PyObject *obj, float *val)
2864 {
2865 const char* errmsg = val ? "float" : (char*)0;
2866 double v;
2867 if (SWIG_AsVal_double(obj, &v)) {
2868 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2869 if (val) *val = (float)(v);
2870 return 1;
2871 } else {
2872 return 0;
2873 }
2874 } else {
2875 PyErr_Clear();
2876 }
2877 if (val) {
2878 SWIG_type_error(errmsg, obj);
2879 }
2880 return 0;
2881 }
2882
2883
2884 SWIGINTERNSHORT float
2885 SWIG_As_float(PyObject* obj)
2886 {
2887 float v;
2888 if (!SWIG_AsVal_float(obj, &v)) {
2889 /*
2890 this is needed to make valgrind/purify happier.
2891 */
2892 memset((void*)&v, 0, sizeof(float));
2893 }
2894 return v;
2895 }
2896
2897
2898 SWIGINTERNSHORT int
2899 SWIG_Check_float(PyObject* obj)
2900 {
2901 return SWIG_AsVal_float(obj, (float*)0);
2902 }
2903
2904
2905 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2906 #define SWIG_From_float PyFloat_FromDouble
2907 /*@@*/
2908
2909 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2910 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2911 if (data) {
2912 Py_INCREF(data->m_obj);
2913 return data->m_obj;
2914 } else {
2915 Py_INCREF(Py_None);
2916 return Py_None;
2917 }
2918 }
2919
2920 // Figure out the type of the sizer item
2921
2922 struct wxPySizerItemInfo {
2923 wxPySizerItemInfo()
2924 : window(NULL), sizer(NULL), gotSize(false),
2925 size(wxDefaultSize), gotPos(false), pos(-1)
2926 {}
2927
2928 wxWindow* window;
2929 wxSizer* sizer;
2930 bool gotSize;
2931 wxSize size;
2932 bool gotPos;
2933 int pos;
2934 };
2935
2936 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2937
2938 wxPySizerItemInfo info;
2939 wxSize size;
2940 wxSize* sizePtr = &size;
2941
2942 // Find out what the type of the item is
2943 // try wxWindow
2944 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2945 PyErr_Clear();
2946 info.window = NULL;
2947
2948 // try wxSizer
2949 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2950 PyErr_Clear();
2951 info.sizer = NULL;
2952
2953 // try wxSize or (w,h)
2954 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2955 info.size = *sizePtr;
2956 info.gotSize = true;
2957 }
2958
2959 // or a single int
2960 if (checkIdx && PyInt_Check(item)) {
2961 info.pos = PyInt_AsLong(item);
2962 info.gotPos = true;
2963 }
2964 }
2965 }
2966
2967 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2968 // no expected type, figure out what kind of error message to generate
2969 if ( !checkSize && !checkIdx )
2970 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2971 else if ( checkSize && !checkIdx )
2972 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2973 else if ( !checkSize && checkIdx)
2974 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2975 else
2976 // can this one happen?
2977 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2978 }
2979
2980 return info;
2981 }
2982
2983 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2984 if (!self->GetClientObject())
2985 self->SetClientObject(new wxPyOORClientData(_self));
2986 }
2987 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2988
2989 wxPyUserData* data = NULL;
2990 bool blocked = wxPyBeginBlockThreads();
2991 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2992 if ( userData && (info.window || info.sizer || info.gotSize) )
2993 data = new wxPyUserData(userData);
2994 wxPyEndBlockThreads(blocked);
2995
2996 // Now call the real Add method if a valid item type was found
2997 if ( info.window )
2998 return self->Add(info.window, proportion, flag, border, data);
2999 else if ( info.sizer )
3000 return self->Add(info.sizer, proportion, flag, border, data);
3001 else if (info.gotSize)
3002 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3003 proportion, flag, border, data);
3004 else
3005 return NULL;
3006 }
3007 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3008
3009 wxPyUserData* data = NULL;
3010 bool blocked = wxPyBeginBlockThreads();
3011 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3012 if ( userData && (info.window || info.sizer || info.gotSize) )
3013 data = new wxPyUserData(userData);
3014 wxPyEndBlockThreads(blocked);
3015
3016 // Now call the real Insert method if a valid item type was found
3017 if ( info.window )
3018 return self->Insert(before, info.window, proportion, flag, border, data);
3019 else if ( info.sizer )
3020 return self->Insert(before, info.sizer, proportion, flag, border, data);
3021 else if (info.gotSize)
3022 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3023 proportion, flag, border, data);
3024 else
3025 return NULL;
3026 }
3027 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3028
3029 wxPyUserData* data = NULL;
3030 bool blocked = wxPyBeginBlockThreads();
3031 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3032 if ( userData && (info.window || info.sizer || info.gotSize) )
3033 data = new wxPyUserData(userData);
3034 wxPyEndBlockThreads(blocked);
3035
3036 // Now call the real Prepend method if a valid item type was found
3037 if ( info.window )
3038 return self->Prepend(info.window, proportion, flag, border, data);
3039 else if ( info.sizer )
3040 return self->Prepend(info.sizer, proportion, flag, border, data);
3041 else if (info.gotSize)
3042 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3043 proportion, flag, border, data);
3044 else
3045 return NULL;
3046 }
3047 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3048 bool blocked = wxPyBeginBlockThreads();
3049 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3050 wxPyEndBlockThreads(blocked);
3051 if ( info.window )
3052 return self->Remove(info.window);
3053 else if ( info.sizer )
3054 return self->Remove(info.sizer);
3055 else if ( info.gotPos )
3056 return self->Remove(info.pos);
3057 else
3058 return false;
3059 }
3060 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3061 bool blocked = wxPyBeginBlockThreads();
3062 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3063 wxPyEndBlockThreads(blocked);
3064 if ( info.window )
3065 return self->Detach(info.window);
3066 else if ( info.sizer )
3067 return self->Detach(info.sizer);
3068 else if ( info.gotPos )
3069 return self->Detach(info.pos);
3070 else
3071 return false;
3072 }
3073 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3074 bool blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->GetItem(info.window);
3079 else if ( info.sizer )
3080 return self->GetItem(info.sizer);
3081 else if ( info.gotPos )
3082 return self->GetItem(info.pos);
3083 else
3084 return NULL;
3085 }
3086 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3087 bool blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 self->SetItemMinSize(info.window, size);
3092 else if ( info.sizer )
3093 self->SetItemMinSize(info.sizer, size);
3094 else if ( info.gotPos )
3095 self->SetItemMinSize(info.pos, size);
3096 }
3097 static PyObject *wxSizer_GetChildren(wxSizer *self){
3098 wxSizerItemList& list = self->GetChildren();
3099 return wxPy_ConvertList(&list);
3100 }
3101 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3102 bool blocked = wxPyBeginBlockThreads();
3103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3104 wxPyEndBlockThreads(blocked);
3105 if ( info.window )
3106 return self->Show(info.window, show, recursive);
3107 else if ( info.sizer )
3108 return self->Show(info.sizer, show, recursive);
3109 else if ( info.gotPos )
3110 return self->Show(info.pos, show);
3111 else
3112 return false;
3113 }
3114 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3115 bool blocked = wxPyBeginBlockThreads();
3116 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3117 wxPyEndBlockThreads(blocked);
3118 if ( info.window )
3119 return self->IsShown(info.window);
3120 else if ( info.sizer )
3121 return self->IsShown(info.sizer);
3122 else if ( info.gotPos )
3123 return self->IsShown(info.pos);
3124 else
3125 return false;
3126 }
3127
3128 // See pyclasses.h
3129 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3130 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3131 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3132
3133
3134
3135
3136 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3137 {
3138 if (source == Py_None) {
3139 **obj = wxGBPosition(-1,-1);
3140 return true;
3141 }
3142 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3143 }
3144
3145 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3146 {
3147 if (source == Py_None) {
3148 **obj = wxGBSpan(-1,-1);
3149 return true;
3150 }
3151 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3152 }
3153
3154
3155 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3156 self->SetRow(row);
3157 self->SetCol(col);
3158 }
3159 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3160 bool blocked = wxPyBeginBlockThreads();
3161 PyObject* tup = PyTuple_New(2);
3162 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3163 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3164 wxPyEndBlockThreads(blocked);
3165 return tup;
3166 }
3167 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3168 self->SetRowspan(rowspan);
3169 self->SetColspan(colspan);
3170 }
3171 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3172 bool blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3175 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3176 wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3180 wxPyUserData* data = NULL;
3181 if ( userData ) {
3182 bool blocked = wxPyBeginBlockThreads();
3183 data = new wxPyUserData(userData);
3184 wxPyEndBlockThreads(blocked);
3185 }
3186 return new wxGBSizerItem(window, pos, span, flag, border, data);
3187 }
3188 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3189 wxPyUserData* data = NULL;
3190 if ( userData ) {
3191 bool blocked = wxPyBeginBlockThreads();
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194 }
3195 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3196 }
3197 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3198 wxPyUserData* data = NULL;
3199 if ( userData ) {
3200 bool blocked = wxPyBeginBlockThreads();
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203 }
3204 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3205 }
3206 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3207 int row, col;
3208 self->GetEndPos(row, col);
3209 return wxGBPosition(row, col);
3210 }
3211 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3212
3213 wxPyUserData* data = NULL;
3214 bool blocked = wxPyBeginBlockThreads();
3215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3216 if ( userData && (info.window || info.sizer || info.gotSize) )
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219
3220 // Now call the real Add method if a valid item type was found
3221 if ( info.window )
3222 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3223 else if ( info.sizer )
3224 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3225 else if (info.gotSize)
3226 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3227 pos, span, flag, border, data);
3228 return NULL;
3229 }
3230
3231
3232 #ifdef __cplusplus
3233 extern "C" {
3234 #endif
3235 static int _wrap_EmptyString_set(PyObject *) {
3236 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3237 return 1;
3238 }
3239
3240
3241 static PyObject *_wrap_EmptyString_get(void) {
3242 PyObject *pyobj;
3243
3244 {
3245 #if wxUSE_UNICODE
3246 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3247 #else
3248 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3249 #endif
3250 }
3251 return pyobj;
3252 }
3253
3254
3255 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3256 PyObject *resultobj;
3257 wxObject *arg1 = (wxObject *) 0 ;
3258 wxString result;
3259 PyObject * obj0 = 0 ;
3260 char *kwnames[] = {
3261 (char *) "self", NULL
3262 };
3263
3264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3266 if (SWIG_arg_fail(1)) SWIG_fail;
3267 {
3268 PyThreadState* __tstate = wxPyBeginAllowThreads();
3269 result = wxObject_GetClassName(arg1);
3270
3271 wxPyEndAllowThreads(__tstate);
3272 if (PyErr_Occurred()) SWIG_fail;
3273 }
3274 {
3275 #if wxUSE_UNICODE
3276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3277 #else
3278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3279 #endif
3280 }
3281 return resultobj;
3282 fail:
3283 return NULL;
3284 }
3285
3286
3287 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxObject *arg1 = (wxObject *) 0 ;
3290 PyObject * obj0 = 0 ;
3291 char *kwnames[] = {
3292 (char *) "self", NULL
3293 };
3294
3295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3297 if (SWIG_arg_fail(1)) SWIG_fail;
3298 {
3299 PyThreadState* __tstate = wxPyBeginAllowThreads();
3300 wxObject_Destroy(arg1);
3301
3302 wxPyEndAllowThreads(__tstate);
3303 if (PyErr_Occurred()) SWIG_fail;
3304 }
3305 Py_INCREF(Py_None); resultobj = Py_None;
3306 return resultobj;
3307 fail:
3308 return NULL;
3309 }
3310
3311
3312 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3313 PyObject *obj;
3314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3315 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3316 Py_INCREF(obj);
3317 return Py_BuildValue((char *)"");
3318 }
3319 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxSize *arg1 = (wxSize *) 0 ;
3322 int arg2 ;
3323 PyObject * obj0 = 0 ;
3324 PyObject * obj1 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "self",(char *) "x", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3331 if (SWIG_arg_fail(1)) SWIG_fail;
3332 {
3333 arg2 = (int)(SWIG_As_int(obj1));
3334 if (SWIG_arg_fail(2)) SWIG_fail;
3335 }
3336 if (arg1) (arg1)->x = arg2;
3337
3338 Py_INCREF(Py_None); resultobj = Py_None;
3339 return resultobj;
3340 fail:
3341 return NULL;
3342 }
3343
3344
3345 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxSize *arg1 = (wxSize *) 0 ;
3348 int result;
3349 PyObject * obj0 = 0 ;
3350 char *kwnames[] = {
3351 (char *) "self", NULL
3352 };
3353
3354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3356 if (SWIG_arg_fail(1)) SWIG_fail;
3357 result = (int) ((arg1)->x);
3358
3359 {
3360 resultobj = SWIG_From_int((int)(result));
3361 }
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxSize *arg1 = (wxSize *) 0 ;
3371 int arg2 ;
3372 PyObject * obj0 = 0 ;
3373 PyObject * obj1 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "self",(char *) "y", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3380 if (SWIG_arg_fail(1)) SWIG_fail;
3381 {
3382 arg2 = (int)(SWIG_As_int(obj1));
3383 if (SWIG_arg_fail(2)) SWIG_fail;
3384 }
3385 if (arg1) (arg1)->y = arg2;
3386
3387 Py_INCREF(Py_None); resultobj = Py_None;
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxSize *arg1 = (wxSize *) 0 ;
3397 int result;
3398 PyObject * obj0 = 0 ;
3399 char *kwnames[] = {
3400 (char *) "self", NULL
3401 };
3402
3403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3405 if (SWIG_arg_fail(1)) SWIG_fail;
3406 result = (int) ((arg1)->y);
3407
3408 {
3409 resultobj = SWIG_From_int((int)(result));
3410 }
3411 return resultobj;
3412 fail:
3413 return NULL;
3414 }
3415
3416
3417 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3418 PyObject *resultobj;
3419 int arg1 = (int) 0 ;
3420 int arg2 = (int) 0 ;
3421 wxSize *result;
3422 PyObject * obj0 = 0 ;
3423 PyObject * obj1 = 0 ;
3424 char *kwnames[] = {
3425 (char *) "w",(char *) "h", NULL
3426 };
3427
3428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3429 if (obj0) {
3430 {
3431 arg1 = (int)(SWIG_As_int(obj0));
3432 if (SWIG_arg_fail(1)) SWIG_fail;
3433 }
3434 }
3435 if (obj1) {
3436 {
3437 arg2 = (int)(SWIG_As_int(obj1));
3438 if (SWIG_arg_fail(2)) SWIG_fail;
3439 }
3440 }
3441 {
3442 PyThreadState* __tstate = wxPyBeginAllowThreads();
3443 result = (wxSize *)new wxSize(arg1,arg2);
3444
3445 wxPyEndAllowThreads(__tstate);
3446 if (PyErr_Occurred()) SWIG_fail;
3447 }
3448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3449 return resultobj;
3450 fail:
3451 return NULL;
3452 }
3453
3454
3455 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj;
3457 wxSize *arg1 = (wxSize *) 0 ;
3458 PyObject * obj0 = 0 ;
3459 char *kwnames[] = {
3460 (char *) "self", NULL
3461 };
3462
3463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3465 if (SWIG_arg_fail(1)) SWIG_fail;
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 delete arg1;
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 Py_INCREF(Py_None); resultobj = Py_None;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxSize *arg1 = (wxSize *) 0 ;
3483 wxSize *arg2 = 0 ;
3484 bool result;
3485 wxSize temp2 ;
3486 PyObject * obj0 = 0 ;
3487 PyObject * obj1 = 0 ;
3488 char *kwnames[] = {
3489 (char *) "self",(char *) "sz", NULL
3490 };
3491
3492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3494 if (SWIG_arg_fail(1)) SWIG_fail;
3495 {
3496 arg2 = &temp2;
3497 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3498 }
3499 {
3500 PyThreadState* __tstate = wxPyBeginAllowThreads();
3501 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3502
3503 wxPyEndAllowThreads(__tstate);
3504 if (PyErr_Occurred()) SWIG_fail;
3505 }
3506 {
3507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3508 }
3509 return resultobj;
3510 fail:
3511 return NULL;
3512 }
3513
3514
3515 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3516 PyObject *resultobj;
3517 wxSize *arg1 = (wxSize *) 0 ;
3518 wxSize *arg2 = 0 ;
3519 bool result;
3520 wxSize temp2 ;
3521 PyObject * obj0 = 0 ;
3522 PyObject * obj1 = 0 ;
3523 char *kwnames[] = {
3524 (char *) "self",(char *) "sz", NULL
3525 };
3526
3527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3529 if (SWIG_arg_fail(1)) SWIG_fail;
3530 {
3531 arg2 = &temp2;
3532 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3533 }
3534 {
3535 PyThreadState* __tstate = wxPyBeginAllowThreads();
3536 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3537
3538 wxPyEndAllowThreads(__tstate);
3539 if (PyErr_Occurred()) SWIG_fail;
3540 }
3541 {
3542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3543 }
3544 return resultobj;
3545 fail:
3546 return NULL;
3547 }
3548
3549
3550 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3551 PyObject *resultobj;
3552 wxSize *arg1 = (wxSize *) 0 ;
3553 wxSize *arg2 = 0 ;
3554 wxSize result;
3555 wxSize temp2 ;
3556 PyObject * obj0 = 0 ;
3557 PyObject * obj1 = 0 ;
3558 char *kwnames[] = {
3559 (char *) "self",(char *) "sz", NULL
3560 };
3561
3562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3564 if (SWIG_arg_fail(1)) SWIG_fail;
3565 {
3566 arg2 = &temp2;
3567 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3568 }
3569 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = (arg1)->operator +((wxSize const &)*arg2);
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 {
3577 wxSize * resultptr;
3578 resultptr = new wxSize((wxSize &)(result));
3579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3580 }
3581 return resultobj;
3582 fail:
3583 return NULL;
3584 }
3585
3586
3587 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3588 PyObject *resultobj;
3589 wxSize *arg1 = (wxSize *) 0 ;
3590 wxSize *arg2 = 0 ;
3591 wxSize result;
3592 wxSize temp2 ;
3593 PyObject * obj0 = 0 ;
3594 PyObject * obj1 = 0 ;
3595 char *kwnames[] = {
3596 (char *) "self",(char *) "sz", NULL
3597 };
3598
3599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 {
3603 arg2 = &temp2;
3604 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3605 }
3606 {
3607 PyThreadState* __tstate = wxPyBeginAllowThreads();
3608 result = (arg1)->operator -((wxSize const &)*arg2);
3609
3610 wxPyEndAllowThreads(__tstate);
3611 if (PyErr_Occurred()) SWIG_fail;
3612 }
3613 {
3614 wxSize * resultptr;
3615 resultptr = new wxSize((wxSize &)(result));
3616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3617 }
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj;
3626 wxSize *arg1 = (wxSize *) 0 ;
3627 wxSize *arg2 = 0 ;
3628 wxSize temp2 ;
3629 PyObject * obj0 = 0 ;
3630 PyObject * obj1 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "self",(char *) "sz", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3637 if (SWIG_arg_fail(1)) SWIG_fail;
3638 {
3639 arg2 = &temp2;
3640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 (arg1)->IncTo((wxSize const &)*arg2);
3645
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 Py_INCREF(Py_None); resultobj = Py_None;
3650 return resultobj;
3651 fail:
3652 return NULL;
3653 }
3654
3655
3656 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3657 PyObject *resultobj;
3658 wxSize *arg1 = (wxSize *) 0 ;
3659 wxSize *arg2 = 0 ;
3660 wxSize temp2 ;
3661 PyObject * obj0 = 0 ;
3662 PyObject * obj1 = 0 ;
3663 char *kwnames[] = {
3664 (char *) "self",(char *) "sz", NULL
3665 };
3666
3667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3669 if (SWIG_arg_fail(1)) SWIG_fail;
3670 {
3671 arg2 = &temp2;
3672 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3673 }
3674 {
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 (arg1)->DecTo((wxSize const &)*arg2);
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 return resultobj;
3683 fail:
3684 return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxSize *arg1 = (wxSize *) 0 ;
3691 int arg2 ;
3692 int arg3 ;
3693 PyObject * obj0 = 0 ;
3694 PyObject * obj1 = 0 ;
3695 PyObject * obj2 = 0 ;
3696 char *kwnames[] = {
3697 (char *) "self",(char *) "w",(char *) "h", NULL
3698 };
3699
3700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3702 if (SWIG_arg_fail(1)) SWIG_fail;
3703 {
3704 arg2 = (int)(SWIG_As_int(obj1));
3705 if (SWIG_arg_fail(2)) SWIG_fail;
3706 }
3707 {
3708 arg3 = (int)(SWIG_As_int(obj2));
3709 if (SWIG_arg_fail(3)) SWIG_fail;
3710 }
3711 {
3712 PyThreadState* __tstate = wxPyBeginAllowThreads();
3713 (arg1)->Set(arg2,arg3);
3714
3715 wxPyEndAllowThreads(__tstate);
3716 if (PyErr_Occurred()) SWIG_fail;
3717 }
3718 Py_INCREF(Py_None); resultobj = Py_None;
3719 return resultobj;
3720 fail:
3721 return NULL;
3722 }
3723
3724
3725 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3726 PyObject *resultobj;
3727 wxSize *arg1 = (wxSize *) 0 ;
3728 int arg2 ;
3729 PyObject * obj0 = 0 ;
3730 PyObject * obj1 = 0 ;
3731 char *kwnames[] = {
3732 (char *) "self",(char *) "w", NULL
3733 };
3734
3735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3737 if (SWIG_arg_fail(1)) SWIG_fail;
3738 {
3739 arg2 = (int)(SWIG_As_int(obj1));
3740 if (SWIG_arg_fail(2)) SWIG_fail;
3741 }
3742 {
3743 PyThreadState* __tstate = wxPyBeginAllowThreads();
3744 (arg1)->SetWidth(arg2);
3745
3746 wxPyEndAllowThreads(__tstate);
3747 if (PyErr_Occurred()) SWIG_fail;
3748 }
3749 Py_INCREF(Py_None); resultobj = Py_None;
3750 return resultobj;
3751 fail:
3752 return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3757 PyObject *resultobj;
3758 wxSize *arg1 = (wxSize *) 0 ;
3759 int arg2 ;
3760 PyObject * obj0 = 0 ;
3761 PyObject * obj1 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "h", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 (arg1)->SetHeight(arg2);
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 Py_INCREF(Py_None); resultobj = Py_None;
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxSize *arg1 = (wxSize *) 0 ;
3790 int result;
3791 PyObject * obj0 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = (int)((wxSize const *)arg1)->GetWidth();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 resultobj = SWIG_From_int((int)(result));
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 int result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (int)((wxSize const *)arg1)->GetHeight();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = SWIG_From_int((int)(result));
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 bool result;
3847 PyObject * obj0 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 {
3863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxSize *arg1 = (wxSize *) 0 ;
3874 wxSize *arg2 = 0 ;
3875 wxSize temp2 ;
3876 PyObject * obj0 = 0 ;
3877 PyObject * obj1 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self",(char *) "size", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 arg2 = &temp2;
3887 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3888 }
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 (arg1)->SetDefaults((wxSize const &)*arg2);
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 Py_INCREF(Py_None); resultobj = Py_None;
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3904 PyObject *resultobj;
3905 wxSize *arg1 = (wxSize *) 0 ;
3906 PyObject *result;
3907 PyObject * obj0 = 0 ;
3908 char *kwnames[] = {
3909 (char *) "self", NULL
3910 };
3911
3912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3914 if (SWIG_arg_fail(1)) SWIG_fail;
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 result = (PyObject *)wxSize_Get(arg1);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 resultobj = result;
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3930 PyObject *obj;
3931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3932 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3933 Py_INCREF(obj);
3934 return Py_BuildValue((char *)"");
3935 }
3936 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3939 double arg2 ;
3940 PyObject * obj0 = 0 ;
3941 PyObject * obj1 = 0 ;
3942 char *kwnames[] = {
3943 (char *) "self",(char *) "x", NULL
3944 };
3945
3946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3948 if (SWIG_arg_fail(1)) SWIG_fail;
3949 {
3950 arg2 = (double)(SWIG_As_double(obj1));
3951 if (SWIG_arg_fail(2)) SWIG_fail;
3952 }
3953 if (arg1) (arg1)->x = arg2;
3954
3955 Py_INCREF(Py_None); resultobj = Py_None;
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3965 double result;
3966 PyObject * obj0 = 0 ;
3967 char *kwnames[] = {
3968 (char *) "self", NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3973 if (SWIG_arg_fail(1)) SWIG_fail;
3974 result = (double) ((arg1)->x);
3975
3976 {
3977 resultobj = SWIG_From_double((double)(result));
3978 }
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3988 double arg2 ;
3989 PyObject * obj0 = 0 ;
3990 PyObject * obj1 = 0 ;
3991 char *kwnames[] = {
3992 (char *) "self",(char *) "y", NULL
3993 };
3994
3995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3997 if (SWIG_arg_fail(1)) SWIG_fail;
3998 {
3999 arg2 = (double)(SWIG_As_double(obj1));
4000 if (SWIG_arg_fail(2)) SWIG_fail;
4001 }
4002 if (arg1) (arg1)->y = arg2;
4003
4004 Py_INCREF(Py_None); resultobj = Py_None;
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj;
4013 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4014 double result;
4015 PyObject * obj0 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "self", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4022 if (SWIG_arg_fail(1)) SWIG_fail;
4023 result = (double) ((arg1)->y);
4024
4025 {
4026 resultobj = SWIG_From_double((double)(result));
4027 }
4028 return resultobj;
4029 fail:
4030 return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj;
4036 double arg1 = (double) 0.0 ;
4037 double arg2 = (double) 0.0 ;
4038 wxRealPoint *result;
4039 PyObject * obj0 = 0 ;
4040 PyObject * obj1 = 0 ;
4041 char *kwnames[] = {
4042 (char *) "x",(char *) "y", NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4046 if (obj0) {
4047 {
4048 arg1 = (double)(SWIG_As_double(obj0));
4049 if (SWIG_arg_fail(1)) SWIG_fail;
4050 }
4051 }
4052 if (obj1) {
4053 {
4054 arg2 = (double)(SWIG_As_double(obj1));
4055 if (SWIG_arg_fail(2)) SWIG_fail;
4056 }
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4075 PyObject * obj0 = 0 ;
4076 char *kwnames[] = {
4077 (char *) "self", NULL
4078 };
4079
4080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4082 if (SWIG_arg_fail(1)) SWIG_fail;
4083 {
4084 PyThreadState* __tstate = wxPyBeginAllowThreads();
4085 delete arg1;
4086
4087 wxPyEndAllowThreads(__tstate);
4088 if (PyErr_Occurred()) SWIG_fail;
4089 }
4090 Py_INCREF(Py_None); resultobj = Py_None;
4091 return resultobj;
4092 fail:
4093 return NULL;
4094 }
4095
4096
4097 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4098 PyObject *resultobj;
4099 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4100 wxRealPoint *arg2 = 0 ;
4101 bool result;
4102 wxRealPoint temp2 ;
4103 PyObject * obj0 = 0 ;
4104 PyObject * obj1 = 0 ;
4105 char *kwnames[] = {
4106 (char *) "self",(char *) "pt", NULL
4107 };
4108
4109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4111 if (SWIG_arg_fail(1)) SWIG_fail;
4112 {
4113 arg2 = &temp2;
4114 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4115 }
4116 {
4117 PyThreadState* __tstate = wxPyBeginAllowThreads();
4118 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4119
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 {
4124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4125 }
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj;
4134 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4135 wxRealPoint *arg2 = 0 ;
4136 bool result;
4137 wxRealPoint temp2 ;
4138 PyObject * obj0 = 0 ;
4139 PyObject * obj1 = 0 ;
4140 char *kwnames[] = {
4141 (char *) "self",(char *) "pt", NULL
4142 };
4143
4144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 {
4148 arg2 = &temp2;
4149 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4150 }
4151 {
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4154
4155 wxPyEndAllowThreads(__tstate);
4156 if (PyErr_Occurred()) SWIG_fail;
4157 }
4158 {
4159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4160 }
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj;
4169 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4170 wxRealPoint *arg2 = 0 ;
4171 wxRealPoint result;
4172 wxRealPoint temp2 ;
4173 PyObject * obj0 = 0 ;
4174 PyObject * obj1 = 0 ;
4175 char *kwnames[] = {
4176 (char *) "self",(char *) "pt", NULL
4177 };
4178
4179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4181 if (SWIG_arg_fail(1)) SWIG_fail;
4182 {
4183 arg2 = &temp2;
4184 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4185 }
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 {
4194 wxRealPoint * resultptr;
4195 resultptr = new wxRealPoint((wxRealPoint &)(result));
4196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4197 }
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj;
4206 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4207 wxRealPoint *arg2 = 0 ;
4208 wxRealPoint result;
4209 wxRealPoint temp2 ;
4210 PyObject * obj0 = 0 ;
4211 PyObject * obj1 = 0 ;
4212 char *kwnames[] = {
4213 (char *) "self",(char *) "pt", NULL
4214 };
4215
4216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4218 if (SWIG_arg_fail(1)) SWIG_fail;
4219 {
4220 arg2 = &temp2;
4221 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4222 }
4223 {
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4226
4227 wxPyEndAllowThreads(__tstate);
4228 if (PyErr_Occurred()) SWIG_fail;
4229 }
4230 {
4231 wxRealPoint * resultptr;
4232 resultptr = new wxRealPoint((wxRealPoint &)(result));
4233 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4234 }
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj;
4243 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4244 double arg2 ;
4245 double arg3 ;
4246 PyObject * obj0 = 0 ;
4247 PyObject * obj1 = 0 ;
4248 PyObject * obj2 = 0 ;
4249 char *kwnames[] = {
4250 (char *) "self",(char *) "x",(char *) "y", NULL
4251 };
4252
4253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4255 if (SWIG_arg_fail(1)) SWIG_fail;
4256 {
4257 arg2 = (double)(SWIG_As_double(obj1));
4258 if (SWIG_arg_fail(2)) SWIG_fail;
4259 }
4260 {
4261 arg3 = (double)(SWIG_As_double(obj2));
4262 if (SWIG_arg_fail(3)) SWIG_fail;
4263 }
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 wxRealPoint_Set(arg1,arg2,arg3);
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 Py_INCREF(Py_None); resultobj = Py_None;
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4279 PyObject *resultobj;
4280 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4281 PyObject *result;
4282 PyObject * obj0 = 0 ;
4283 char *kwnames[] = {
4284 (char *) "self", NULL
4285 };
4286
4287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4289 if (SWIG_arg_fail(1)) SWIG_fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = (PyObject *)wxRealPoint_Get(arg1);
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 resultobj = result;
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4305 PyObject *obj;
4306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4307 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4308 Py_INCREF(obj);
4309 return Py_BuildValue((char *)"");
4310 }
4311 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj;
4313 wxPoint *arg1 = (wxPoint *) 0 ;
4314 int arg2 ;
4315 PyObject * obj0 = 0 ;
4316 PyObject * obj1 = 0 ;
4317 char *kwnames[] = {
4318 (char *) "self",(char *) "x", NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4323 if (SWIG_arg_fail(1)) SWIG_fail;
4324 {
4325 arg2 = (int)(SWIG_As_int(obj1));
4326 if (SWIG_arg_fail(2)) SWIG_fail;
4327 }
4328 if (arg1) (arg1)->x = arg2;
4329
4330 Py_INCREF(Py_None); resultobj = Py_None;
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPoint *arg1 = (wxPoint *) 0 ;
4340 int result;
4341 PyObject * obj0 = 0 ;
4342 char *kwnames[] = {
4343 (char *) "self", NULL
4344 };
4345
4346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4348 if (SWIG_arg_fail(1)) SWIG_fail;
4349 result = (int) ((arg1)->x);
4350
4351 {
4352 resultobj = SWIG_From_int((int)(result));
4353 }
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj;
4362 wxPoint *arg1 = (wxPoint *) 0 ;
4363 int arg2 ;
4364 PyObject * obj0 = 0 ;
4365 PyObject * obj1 = 0 ;
4366 char *kwnames[] = {
4367 (char *) "self",(char *) "y", NULL
4368 };
4369
4370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4372 if (SWIG_arg_fail(1)) SWIG_fail;
4373 {
4374 arg2 = (int)(SWIG_As_int(obj1));
4375 if (SWIG_arg_fail(2)) SWIG_fail;
4376 }
4377 if (arg1) (arg1)->y = arg2;
4378
4379 Py_INCREF(Py_None); resultobj = Py_None;
4380 return resultobj;
4381 fail:
4382 return NULL;
4383 }
4384
4385
4386 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4387 PyObject *resultobj;
4388 wxPoint *arg1 = (wxPoint *) 0 ;
4389 int result;
4390 PyObject * obj0 = 0 ;
4391 char *kwnames[] = {
4392 (char *) "self", NULL
4393 };
4394
4395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4397 if (SWIG_arg_fail(1)) SWIG_fail;
4398 result = (int) ((arg1)->y);
4399
4400 {
4401 resultobj = SWIG_From_int((int)(result));
4402 }
4403 return resultobj;
4404 fail:
4405 return NULL;
4406 }
4407
4408
4409 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4410 PyObject *resultobj;
4411 int arg1 = (int) 0 ;
4412 int arg2 = (int) 0 ;
4413 wxPoint *result;
4414 PyObject * obj0 = 0 ;
4415 PyObject * obj1 = 0 ;
4416 char *kwnames[] = {
4417 (char *) "x",(char *) "y", NULL
4418 };
4419
4420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4421 if (obj0) {
4422 {
4423 arg1 = (int)(SWIG_As_int(obj0));
4424 if (SWIG_arg_fail(1)) SWIG_fail;
4425 }
4426 }
4427 if (obj1) {
4428 {
4429 arg2 = (int)(SWIG_As_int(obj1));
4430 if (SWIG_arg_fail(2)) SWIG_fail;
4431 }
4432 }
4433 {
4434 PyThreadState* __tstate = wxPyBeginAllowThreads();
4435 result = (wxPoint *)new wxPoint(arg1,arg2);
4436
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4448 PyObject *resultobj;
4449 wxPoint *arg1 = (wxPoint *) 0 ;
4450 PyObject * obj0 = 0 ;
4451 char *kwnames[] = {
4452 (char *) "self", NULL
4453 };
4454
4455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4457 if (SWIG_arg_fail(1)) SWIG_fail;
4458 {
4459 PyThreadState* __tstate = wxPyBeginAllowThreads();
4460 delete arg1;
4461
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 Py_INCREF(Py_None); resultobj = Py_None;
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj;
4474 wxPoint *arg1 = (wxPoint *) 0 ;
4475 wxPoint *arg2 = 0 ;
4476 bool result;
4477 wxPoint temp2 ;
4478 PyObject * obj0 = 0 ;
4479 PyObject * obj1 = 0 ;
4480 char *kwnames[] = {
4481 (char *) "self",(char *) "pt", NULL
4482 };
4483
4484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4486 if (SWIG_arg_fail(1)) SWIG_fail;
4487 {
4488 arg2 = &temp2;
4489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4490 }
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 {
4499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4500 }
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj;
4509 wxPoint *arg1 = (wxPoint *) 0 ;
4510 wxPoint *arg2 = 0 ;
4511 bool result;
4512 wxPoint temp2 ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 char *kwnames[] = {
4516 (char *) "self",(char *) "pt", NULL
4517 };
4518
4519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4521 if (SWIG_arg_fail(1)) SWIG_fail;
4522 {
4523 arg2 = &temp2;
4524 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4525 }
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4529
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 {
4534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4535 }
4536 return resultobj;
4537 fail:
4538 return NULL;
4539 }
4540
4541
4542 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4543 PyObject *resultobj;
4544 wxPoint *arg1 = (wxPoint *) 0 ;
4545 wxPoint *arg2 = 0 ;
4546 wxPoint result;
4547 wxPoint temp2 ;
4548 PyObject * obj0 = 0 ;
4549 PyObject * obj1 = 0 ;
4550 char *kwnames[] = {
4551 (char *) "self",(char *) "pt", NULL
4552 };
4553
4554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(1)) SWIG_fail;
4557 {
4558 arg2 = &temp2;
4559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (arg1)->operator +((wxPoint const &)*arg2);
4564
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 wxPoint * resultptr;
4570 resultptr = new wxPoint((wxPoint &)(result));
4571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4572 }
4573 return resultobj;
4574 fail:
4575 return NULL;
4576 }
4577
4578
4579 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4580 PyObject *resultobj;
4581 wxPoint *arg1 = (wxPoint *) 0 ;
4582 wxPoint *arg2 = 0 ;
4583 wxPoint result;
4584 wxPoint temp2 ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 char *kwnames[] = {
4588 (char *) "self",(char *) "pt", NULL
4589 };
4590
4591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4593 if (SWIG_arg_fail(1)) SWIG_fail;
4594 {
4595 arg2 = &temp2;
4596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4597 }
4598 {
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = (arg1)->operator -((wxPoint const &)*arg2);
4601
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 {
4606 wxPoint * resultptr;
4607 resultptr = new wxPoint((wxPoint &)(result));
4608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4609 }
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4617 PyObject *resultobj;
4618 wxPoint *arg1 = (wxPoint *) 0 ;
4619 wxPoint *arg2 = 0 ;
4620 wxPoint *result;
4621 wxPoint temp2 ;
4622 PyObject * obj0 = 0 ;
4623 PyObject * obj1 = 0 ;
4624 char *kwnames[] = {
4625 (char *) "self",(char *) "pt", NULL
4626 };
4627
4628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4630 if (SWIG_arg_fail(1)) SWIG_fail;
4631 {
4632 arg2 = &temp2;
4633 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4634 }
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 {
4638 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4639 result = (wxPoint *) &_result_ref;
4640 }
4641
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj;
4654 wxPoint *arg1 = (wxPoint *) 0 ;
4655 wxPoint *arg2 = 0 ;
4656 wxPoint *result;
4657 wxPoint temp2 ;
4658 PyObject * obj0 = 0 ;
4659 PyObject * obj1 = 0 ;
4660 char *kwnames[] = {
4661 (char *) "self",(char *) "pt", NULL
4662 };
4663
4664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4666 if (SWIG_arg_fail(1)) SWIG_fail;
4667 {
4668 arg2 = &temp2;
4669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4670 }
4671 {
4672 PyThreadState* __tstate = wxPyBeginAllowThreads();
4673 {
4674 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4675 result = (wxPoint *) &_result_ref;
4676 }
4677
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj;
4690 wxPoint *arg1 = (wxPoint *) 0 ;
4691 long arg2 ;
4692 long arg3 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 PyObject * obj2 = 0 ;
4696 char *kwnames[] = {
4697 (char *) "self",(char *) "x",(char *) "y", NULL
4698 };
4699
4700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4702 if (SWIG_arg_fail(1)) SWIG_fail;
4703 {
4704 arg2 = (long)(SWIG_As_long(obj1));
4705 if (SWIG_arg_fail(2)) SWIG_fail;
4706 }
4707 {
4708 arg3 = (long)(SWIG_As_long(obj2));
4709 if (SWIG_arg_fail(3)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 wxPoint_Set(arg1,arg2,arg3);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 Py_INCREF(Py_None); resultobj = Py_None;
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj;
4727 wxPoint *arg1 = (wxPoint *) 0 ;
4728 PyObject *result;
4729 PyObject * obj0 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 result = (PyObject *)wxPoint_Get(arg1);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 resultobj = result;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4752 PyObject *obj;
4753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4754 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4755 Py_INCREF(obj);
4756 return Py_BuildValue((char *)"");
4757 }
4758 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj;
4760 int arg1 = (int) 0 ;
4761 int arg2 = (int) 0 ;
4762 int arg3 = (int) 0 ;
4763 int arg4 = (int) 0 ;
4764 wxRect *result;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 PyObject * obj2 = 0 ;
4768 PyObject * obj3 = 0 ;
4769 char *kwnames[] = {
4770 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4771 };
4772
4773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4774 if (obj0) {
4775 {
4776 arg1 = (int)(SWIG_As_int(obj0));
4777 if (SWIG_arg_fail(1)) SWIG_fail;
4778 }
4779 }
4780 if (obj1) {
4781 {
4782 arg2 = (int)(SWIG_As_int(obj1));
4783 if (SWIG_arg_fail(2)) SWIG_fail;
4784 }
4785 }
4786 if (obj2) {
4787 {
4788 arg3 = (int)(SWIG_As_int(obj2));
4789 if (SWIG_arg_fail(3)) SWIG_fail;
4790 }
4791 }
4792 if (obj3) {
4793 {
4794 arg4 = (int)(SWIG_As_int(obj3));
4795 if (SWIG_arg_fail(4)) SWIG_fail;
4796 }
4797 }
4798 {
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4813 PyObject *resultobj;
4814 wxPoint *arg1 = 0 ;
4815 wxPoint *arg2 = 0 ;
4816 wxRect *result;
4817 wxPoint temp1 ;
4818 wxPoint temp2 ;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 char *kwnames[] = {
4822 (char *) "topLeft",(char *) "bottomRight", NULL
4823 };
4824
4825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4826 {
4827 arg1 = &temp1;
4828 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4829 }
4830 {
4831 arg2 = &temp2;
4832 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4837
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj;
4850 wxPoint *arg1 = 0 ;
4851 wxSize *arg2 = 0 ;
4852 wxRect *result;
4853 wxPoint temp1 ;
4854 wxSize temp2 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "pos",(char *) "size", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4862 {
4863 arg1 = &temp1;
4864 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4865 }
4866 {
4867 arg2 = &temp2;
4868 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4873
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj;
4886 wxSize *arg1 = 0 ;
4887 wxRect *result;
4888 wxSize temp1 ;
4889 PyObject * obj0 = 0 ;
4890 char *kwnames[] = {
4891 (char *) "size", NULL
4892 };
4893
4894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4895 {
4896 arg1 = &temp1;
4897 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxRect *arg1 = (wxRect *) 0 ;
4916 PyObject * obj0 = 0 ;
4917 char *kwnames[] = {
4918 (char *) "self", NULL
4919 };
4920
4921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(1)) SWIG_fail;
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 delete arg1;
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 Py_INCREF(Py_None); resultobj = Py_None;
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxRect *arg1 = (wxRect *) 0 ;
4941 int result;
4942 PyObject * obj0 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "self", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (int)((wxRect const *)arg1)->GetX();
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 {
4958 resultobj = SWIG_From_int((int)(result));
4959 }
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj;
4968 wxRect *arg1 = (wxRect *) 0 ;
4969 int arg2 ;
4970 PyObject * obj0 = 0 ;
4971 PyObject * obj1 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "self",(char *) "x", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(1)) SWIG_fail;
4979 {
4980 arg2 = (int)(SWIG_As_int(obj1));
4981 if (SWIG_arg_fail(2)) SWIG_fail;
4982 }
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 (arg1)->SetX(arg2);
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 Py_INCREF(Py_None); resultobj = Py_None;
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj;
4999 wxRect *arg1 = (wxRect *) 0 ;
5000 int result;
5001 PyObject * obj0 = 0 ;
5002 char *kwnames[] = {
5003 (char *) "self", NULL
5004 };
5005
5006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5008 if (SWIG_arg_fail(1)) SWIG_fail;
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 result = (int)(arg1)->GetY();
5012
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 {
5017 resultobj = SWIG_From_int((int)(result));
5018 }
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5026 PyObject *resultobj;
5027 wxRect *arg1 = (wxRect *) 0 ;
5028 int arg2 ;
5029 PyObject * obj0 = 0 ;
5030 PyObject * obj1 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self",(char *) "y", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 arg2 = (int)(SWIG_As_int(obj1));
5040 if (SWIG_arg_fail(2)) SWIG_fail;
5041 }
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 (arg1)->SetY(arg2);
5045
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 Py_INCREF(Py_None); resultobj = Py_None;
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj;
5058 wxRect *arg1 = (wxRect *) 0 ;
5059 int result;
5060 PyObject * obj0 = 0 ;
5061 char *kwnames[] = {
5062 (char *) "self", NULL
5063 };
5064
5065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (int)((wxRect const *)arg1)->GetWidth();
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 {
5076 resultobj = SWIG_From_int((int)(result));
5077 }
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxRect *arg1 = (wxRect *) 0 ;
5087 int arg2 ;
5088 PyObject * obj0 = 0 ;
5089 PyObject * obj1 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "self",(char *) "w", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 {
5098 arg2 = (int)(SWIG_As_int(obj1));
5099 if (SWIG_arg_fail(2)) SWIG_fail;
5100 }
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 (arg1)->SetWidth(arg2);
5104
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 Py_INCREF(Py_None); resultobj = Py_None;
5109 return resultobj;
5110 fail:
5111 return NULL;
5112 }
5113
5114
5115 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5116 PyObject *resultobj;
5117 wxRect *arg1 = (wxRect *) 0 ;
5118 int result;
5119 PyObject * obj0 = 0 ;
5120 char *kwnames[] = {
5121 (char *) "self", NULL
5122 };
5123
5124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(1)) SWIG_fail;
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (int)((wxRect const *)arg1)->GetHeight();
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 {
5135 resultobj = SWIG_From_int((int)(result));
5136 }
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxRect *arg1 = (wxRect *) 0 ;
5146 int arg2 ;
5147 PyObject * obj0 = 0 ;
5148 PyObject * obj1 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "self",(char *) "h", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5155 if (SWIG_arg_fail(1)) SWIG_fail;
5156 {
5157 arg2 = (int)(SWIG_As_int(obj1));
5158 if (SWIG_arg_fail(2)) SWIG_fail;
5159 }
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 (arg1)->SetHeight(arg2);
5163
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 Py_INCREF(Py_None); resultobj = Py_None;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5175 PyObject *resultobj;
5176 wxRect *arg1 = (wxRect *) 0 ;
5177 wxPoint result;
5178 PyObject * obj0 = 0 ;
5179 char *kwnames[] = {
5180 (char *) "self", NULL
5181 };
5182
5183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5185 if (SWIG_arg_fail(1)) SWIG_fail;
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 result = ((wxRect const *)arg1)->GetPosition();
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 {
5194 wxPoint * resultptr;
5195 resultptr = new wxPoint((wxPoint &)(result));
5196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5197 }
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj;
5206 wxRect *arg1 = (wxRect *) 0 ;
5207 wxPoint *arg2 = 0 ;
5208 wxPoint temp2 ;
5209 PyObject * obj0 = 0 ;
5210 PyObject * obj1 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self",(char *) "p", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 arg2 = &temp2;
5220 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5221 }
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 (arg1)->SetPosition((wxPoint const &)*arg2);
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 Py_INCREF(Py_None); resultobj = Py_None;
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj;
5238 wxRect *arg1 = (wxRect *) 0 ;
5239 wxSize result;
5240 PyObject * obj0 = 0 ;
5241 char *kwnames[] = {
5242 (char *) "self", NULL
5243 };
5244
5245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5247 if (SWIG_arg_fail(1)) SWIG_fail;
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 result = ((wxRect const *)arg1)->GetSize();
5251
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 {
5256 wxSize * resultptr;
5257 resultptr = new wxSize((wxSize &)(result));
5258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5259 }
5260 return resultobj;
5261 fail:
5262 return NULL;
5263 }
5264
5265
5266 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj;
5268 wxRect *arg1 = (wxRect *) 0 ;
5269 wxSize *arg2 = 0 ;
5270 wxSize temp2 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char *kwnames[] = {
5274 (char *) "self",(char *) "s", NULL
5275 };
5276
5277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5279 if (SWIG_arg_fail(1)) SWIG_fail;
5280 {
5281 arg2 = &temp2;
5282 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5283 }
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 (arg1)->SetSize((wxSize const &)*arg2);
5287
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 Py_INCREF(Py_None); resultobj = Py_None;
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 wxPoint result;
5302 PyObject * obj0 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "self", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5309 if (SWIG_arg_fail(1)) SWIG_fail;
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 result = ((wxRect const *)arg1)->GetTopLeft();
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 {
5318 wxPoint * resultptr;
5319 resultptr = new wxPoint((wxPoint &)(result));
5320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5321 }
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
5328 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5329 PyObject *resultobj;
5330 wxRect *arg1 = (wxRect *) 0 ;
5331 wxPoint *arg2 = 0 ;
5332 wxPoint temp2 ;
5333 PyObject * obj0 = 0 ;
5334 PyObject * obj1 = 0 ;
5335 char *kwnames[] = {
5336 (char *) "self",(char *) "p", NULL
5337 };
5338
5339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5341 if (SWIG_arg_fail(1)) SWIG_fail;
5342 {
5343 arg2 = &temp2;
5344 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5345 }
5346 {
5347 PyThreadState* __tstate = wxPyBeginAllowThreads();
5348 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5349
5350 wxPyEndAllowThreads(__tstate);
5351 if (PyErr_Occurred()) SWIG_fail;
5352 }
5353 Py_INCREF(Py_None); resultobj = Py_None;
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5361 PyObject *resultobj;
5362 wxRect *arg1 = (wxRect *) 0 ;
5363 wxPoint result;
5364 PyObject * obj0 = 0 ;
5365 char *kwnames[] = {
5366 (char *) "self", NULL
5367 };
5368
5369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5371 if (SWIG_arg_fail(1)) SWIG_fail;
5372 {
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = ((wxRect const *)arg1)->GetBottomRight();
5375
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 wxPoint * resultptr;
5381 resultptr = new wxPoint((wxPoint &)(result));
5382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5383 }
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5391 PyObject *resultobj;
5392 wxRect *arg1 = (wxRect *) 0 ;
5393 wxPoint *arg2 = 0 ;
5394 wxPoint temp2 ;
5395 PyObject * obj0 = 0 ;
5396 PyObject * obj1 = 0 ;
5397 char *kwnames[] = {
5398 (char *) "self",(char *) "p", NULL
5399 };
5400
5401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5403 if (SWIG_arg_fail(1)) SWIG_fail;
5404 {
5405 arg2 = &temp2;
5406 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5407 }
5408 {
5409 PyThreadState* __tstate = wxPyBeginAllowThreads();
5410 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5411
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 Py_INCREF(Py_None); resultobj = Py_None;
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj;
5424 wxRect *arg1 = (wxRect *) 0 ;
5425 int result;
5426 PyObject * obj0 = 0 ;
5427 char *kwnames[] = {
5428 (char *) "self", NULL
5429 };
5430
5431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5433 if (SWIG_arg_fail(1)) SWIG_fail;
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = (int)((wxRect const *)arg1)->GetLeft();
5437
5438 wxPyEndAllowThreads(__tstate);
5439 if (PyErr_Occurred()) SWIG_fail;
5440 }
5441 {
5442 resultobj = SWIG_From_int((int)(result));
5443 }
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxRect *arg1 = (wxRect *) 0 ;
5453 int result;
5454 PyObject * obj0 = 0 ;
5455 char *kwnames[] = {
5456 (char *) "self", NULL
5457 };
5458
5459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5461 if (SWIG_arg_fail(1)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (int)((wxRect const *)arg1)->GetTop();
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 resultobj = SWIG_From_int((int)(result));
5471 }
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxRect *arg1 = (wxRect *) 0 ;
5481 int result;
5482 PyObject * obj0 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (int)((wxRect const *)arg1)->GetBottom();
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_int((int)(result));
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int result;
5510 PyObject * obj0 = 0 ;
5511 char *kwnames[] = {
5512 (char *) "self", NULL
5513 };
5514
5515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5517 if (SWIG_arg_fail(1)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = (int)((wxRect const *)arg1)->GetRight();
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 resultobj = SWIG_From_int((int)(result));
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxRect *arg1 = (wxRect *) 0 ;
5537 int arg2 ;
5538 PyObject * obj0 = 0 ;
5539 PyObject * obj1 = 0 ;
5540 char *kwnames[] = {
5541 (char *) "self",(char *) "left", NULL
5542 };
5543
5544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5546 if (SWIG_arg_fail(1)) SWIG_fail;
5547 {
5548 arg2 = (int)(SWIG_As_int(obj1));
5549 if (SWIG_arg_fail(2)) SWIG_fail;
5550 }
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 (arg1)->SetLeft(arg2);
5554
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 Py_INCREF(Py_None); resultobj = Py_None;
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5566 PyObject *resultobj;
5567 wxRect *arg1 = (wxRect *) 0 ;
5568 int arg2 ;
5569 PyObject * obj0 = 0 ;
5570 PyObject * obj1 = 0 ;
5571 char *kwnames[] = {
5572 (char *) "self",(char *) "right", NULL
5573 };
5574
5575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5577 if (SWIG_arg_fail(1)) SWIG_fail;
5578 {
5579 arg2 = (int)(SWIG_As_int(obj1));
5580 if (SWIG_arg_fail(2)) SWIG_fail;
5581 }
5582 {
5583 PyThreadState* __tstate = wxPyBeginAllowThreads();
5584 (arg1)->SetRight(arg2);
5585
5586 wxPyEndAllowThreads(__tstate);
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 Py_INCREF(Py_None); resultobj = Py_None;
5590 return resultobj;
5591 fail:
5592 return NULL;
5593 }
5594
5595
5596 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj;
5598 wxRect *arg1 = (wxRect *) 0 ;
5599 int arg2 ;
5600 PyObject * obj0 = 0 ;
5601 PyObject * obj1 = 0 ;
5602 char *kwnames[] = {
5603 (char *) "self",(char *) "top", NULL
5604 };
5605
5606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5608 if (SWIG_arg_fail(1)) SWIG_fail;
5609 {
5610 arg2 = (int)(SWIG_As_int(obj1));
5611 if (SWIG_arg_fail(2)) SWIG_fail;
5612 }
5613 {
5614 PyThreadState* __tstate = wxPyBeginAllowThreads();
5615 (arg1)->SetTop(arg2);
5616
5617 wxPyEndAllowThreads(__tstate);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 Py_INCREF(Py_None); resultobj = Py_None;
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5628 PyObject *resultobj;
5629 wxRect *arg1 = (wxRect *) 0 ;
5630 int arg2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char *kwnames[] = {
5634 (char *) "self",(char *) "bottom", NULL
5635 };
5636
5637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5639 if (SWIG_arg_fail(1)) SWIG_fail;
5640 {
5641 arg2 = (int)(SWIG_As_int(obj1));
5642 if (SWIG_arg_fail(2)) SWIG_fail;
5643 }
5644 {
5645 PyThreadState* __tstate = wxPyBeginAllowThreads();
5646 (arg1)->SetBottom(arg2);
5647
5648 wxPyEndAllowThreads(__tstate);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 Py_INCREF(Py_None); resultobj = Py_None;
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj;
5660 wxRect *arg1 = (wxRect *) 0 ;
5661 int arg2 ;
5662 int arg3 ;
5663 wxRect *result;
5664 PyObject * obj0 = 0 ;
5665 PyObject * obj1 = 0 ;
5666 PyObject * obj2 = 0 ;
5667 char *kwnames[] = {
5668 (char *) "self",(char *) "dx",(char *) "dy", NULL
5669 };
5670
5671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5673 if (SWIG_arg_fail(1)) SWIG_fail;
5674 {
5675 arg2 = (int)(SWIG_As_int(obj1));
5676 if (SWIG_arg_fail(2)) SWIG_fail;
5677 }
5678 {
5679 arg3 = (int)(SWIG_As_int(obj2));
5680 if (SWIG_arg_fail(3)) SWIG_fail;
5681 }
5682 {
5683 PyThreadState* __tstate = wxPyBeginAllowThreads();
5684 {
5685 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5686 result = (wxRect *) &_result_ref;
5687 }
5688
5689 wxPyEndAllowThreads(__tstate);
5690 if (PyErr_Occurred()) SWIG_fail;
5691 }
5692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5700 PyObject *resultobj;
5701 wxRect *arg1 = (wxRect *) 0 ;
5702 int arg2 ;
5703 int arg3 ;
5704 wxRect *result;
5705 PyObject * obj0 = 0 ;
5706 PyObject * obj1 = 0 ;
5707 PyObject * obj2 = 0 ;
5708 char *kwnames[] = {
5709 (char *) "self",(char *) "dx",(char *) "dy", NULL
5710 };
5711
5712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5714 if (SWIG_arg_fail(1)) SWIG_fail;
5715 {
5716 arg2 = (int)(SWIG_As_int(obj1));
5717 if (SWIG_arg_fail(2)) SWIG_fail;
5718 }
5719 {
5720 arg3 = (int)(SWIG_As_int(obj2));
5721 if (SWIG_arg_fail(3)) SWIG_fail;
5722 }
5723 {
5724 PyThreadState* __tstate = wxPyBeginAllowThreads();
5725 {
5726 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5727 result = (wxRect *) &_result_ref;
5728 }
5729
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5734 return resultobj;
5735 fail:
5736 return NULL;
5737 }
5738
5739
5740 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5741 PyObject *resultobj;
5742 wxRect *arg1 = (wxRect *) 0 ;
5743 int arg2 ;
5744 int arg3 ;
5745 PyObject * obj0 = 0 ;
5746 PyObject * obj1 = 0 ;
5747 PyObject * obj2 = 0 ;
5748 char *kwnames[] = {
5749 (char *) "self",(char *) "dx",(char *) "dy", NULL
5750 };
5751
5752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5754 if (SWIG_arg_fail(1)) SWIG_fail;
5755 {
5756 arg2 = (int)(SWIG_As_int(obj1));
5757 if (SWIG_arg_fail(2)) SWIG_fail;
5758 }
5759 {
5760 arg3 = (int)(SWIG_As_int(obj2));
5761 if (SWIG_arg_fail(3)) SWIG_fail;
5762 }
5763 {
5764 PyThreadState* __tstate = wxPyBeginAllowThreads();
5765 (arg1)->Offset(arg2,arg3);
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 Py_INCREF(Py_None); resultobj = Py_None;
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxRect *arg1 = (wxRect *) 0 ;
5780 wxPoint *arg2 = 0 ;
5781 wxPoint temp2 ;
5782 PyObject * obj0 = 0 ;
5783 PyObject * obj1 = 0 ;
5784 char *kwnames[] = {
5785 (char *) "self",(char *) "pt", NULL
5786 };
5787
5788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5790 if (SWIG_arg_fail(1)) SWIG_fail;
5791 {
5792 arg2 = &temp2;
5793 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5794 }
5795 {
5796 PyThreadState* __tstate = wxPyBeginAllowThreads();
5797 (arg1)->Offset((wxPoint const &)*arg2);
5798
5799 wxPyEndAllowThreads(__tstate);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 Py_INCREF(Py_None); resultobj = Py_None;
5803 return resultobj;
5804 fail:
5805 return NULL;
5806 }
5807
5808
5809 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5810 PyObject *resultobj;
5811 wxRect *arg1 = (wxRect *) 0 ;
5812 wxRect *arg2 = 0 ;
5813 wxRect result;
5814 wxRect temp2 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char *kwnames[] = {
5818 (char *) "self",(char *) "rect", NULL
5819 };
5820
5821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5823 if (SWIG_arg_fail(1)) SWIG_fail;
5824 {
5825 arg2 = &temp2;
5826 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5827 }
5828 {
5829 PyThreadState* __tstate = wxPyBeginAllowThreads();
5830 result = (arg1)->Intersect((wxRect const &)*arg2);
5831
5832 wxPyEndAllowThreads(__tstate);
5833 if (PyErr_Occurred()) SWIG_fail;
5834 }
5835 {
5836 wxRect * resultptr;
5837 resultptr = new wxRect((wxRect &)(result));
5838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxRect *arg1 = (wxRect *) 0 ;
5849 wxRect *arg2 = 0 ;
5850 wxRect result;
5851 wxRect temp2 ;
5852 PyObject * obj0 = 0 ;
5853 PyObject * obj1 = 0 ;
5854 char *kwnames[] = {
5855 (char *) "self",(char *) "rect", NULL
5856 };
5857
5858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5860 if (SWIG_arg_fail(1)) SWIG_fail;
5861 {
5862 arg2 = &temp2;
5863 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5864 }
5865 {
5866 PyThreadState* __tstate = wxPyBeginAllowThreads();
5867 result = (arg1)->Union((wxRect const &)*arg2);
5868
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 {
5873 wxRect * resultptr;
5874 resultptr = new wxRect((wxRect &)(result));
5875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5876 }
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj;
5885 wxRect *arg1 = (wxRect *) 0 ;
5886 wxRect *arg2 = 0 ;
5887 wxRect result;
5888 wxRect temp2 ;
5889 PyObject * obj0 = 0 ;
5890 PyObject * obj1 = 0 ;
5891 char *kwnames[] = {
5892 (char *) "self",(char *) "rect", NULL
5893 };
5894
5895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5897 if (SWIG_arg_fail(1)) SWIG_fail;
5898 {
5899 arg2 = &temp2;
5900 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5901 }
5902 {
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5905
5906 wxPyEndAllowThreads(__tstate);
5907 if (PyErr_Occurred()) SWIG_fail;
5908 }
5909 {
5910 wxRect * resultptr;
5911 resultptr = new wxRect((wxRect &)(result));
5912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5913 }
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj;
5922 wxRect *arg1 = (wxRect *) 0 ;
5923 wxRect *arg2 = 0 ;
5924 wxRect *result;
5925 wxRect temp2 ;
5926 PyObject * obj0 = 0 ;
5927 PyObject * obj1 = 0 ;
5928 char *kwnames[] = {
5929 (char *) "self",(char *) "rect", NULL
5930 };
5931
5932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5934 if (SWIG_arg_fail(1)) SWIG_fail;
5935 {
5936 arg2 = &temp2;
5937 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5938 }
5939 {
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 {
5942 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5943 result = (wxRect *) &_result_ref;
5944 }
5945
5946 wxPyEndAllowThreads(__tstate);
5947 if (PyErr_Occurred()) SWIG_fail;
5948 }
5949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5950 return resultobj;
5951 fail:
5952 return NULL;
5953 }
5954
5955
5956 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5957 PyObject *resultobj;
5958 wxRect *arg1 = (wxRect *) 0 ;
5959 wxRect *arg2 = 0 ;
5960 bool result;
5961 wxRect temp2 ;
5962 PyObject * obj0 = 0 ;
5963 PyObject * obj1 = 0 ;
5964 char *kwnames[] = {
5965 (char *) "self",(char *) "rect", NULL
5966 };
5967
5968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5970 if (SWIG_arg_fail(1)) SWIG_fail;
5971 {
5972 arg2 = &temp2;
5973 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5974 }
5975 {
5976 PyThreadState* __tstate = wxPyBeginAllowThreads();
5977 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5978
5979 wxPyEndAllowThreads(__tstate);
5980 if (PyErr_Occurred()) SWIG_fail;
5981 }
5982 {
5983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5984 }
5985 return resultobj;
5986 fail:
5987 return NULL;
5988 }
5989
5990
5991 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj;
5993 wxRect *arg1 = (wxRect *) 0 ;
5994 wxRect *arg2 = 0 ;
5995 bool result;
5996 wxRect temp2 ;
5997 PyObject * obj0 = 0 ;
5998 PyObject * obj1 = 0 ;
5999 char *kwnames[] = {
6000 (char *) "self",(char *) "rect", NULL
6001 };
6002
6003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6005 if (SWIG_arg_fail(1)) SWIG_fail;
6006 {
6007 arg2 = &temp2;
6008 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6009 }
6010 {
6011 PyThreadState* __tstate = wxPyBeginAllowThreads();
6012 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6013
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 {
6018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6019 }
6020 return resultobj;
6021 fail:
6022 return NULL;
6023 }
6024
6025
6026 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6027 PyObject *resultobj;
6028 wxRect *arg1 = (wxRect *) 0 ;
6029 int arg2 ;
6030 int arg3 ;
6031 bool result;
6032 PyObject * obj0 = 0 ;
6033 PyObject * obj1 = 0 ;
6034 PyObject * obj2 = 0 ;
6035 char *kwnames[] = {
6036 (char *) "self",(char *) "x",(char *) "y", NULL
6037 };
6038
6039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6041 if (SWIG_arg_fail(1)) SWIG_fail;
6042 {
6043 arg2 = (int)(SWIG_As_int(obj1));
6044 if (SWIG_arg_fail(2)) SWIG_fail;
6045 }
6046 {
6047 arg3 = (int)(SWIG_As_int(obj2));
6048 if (SWIG_arg_fail(3)) SWIG_fail;
6049 }
6050 {
6051 PyThreadState* __tstate = wxPyBeginAllowThreads();
6052 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6053
6054 wxPyEndAllowThreads(__tstate);
6055 if (PyErr_Occurred()) SWIG_fail;
6056 }
6057 {
6058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6059 }
6060 return resultobj;
6061 fail:
6062 return NULL;
6063 }
6064
6065
6066 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6067 PyObject *resultobj;
6068 wxRect *arg1 = (wxRect *) 0 ;
6069 wxPoint *arg2 = 0 ;
6070 bool result;
6071 wxPoint temp2 ;
6072 PyObject * obj0 = 0 ;
6073 PyObject * obj1 = 0 ;
6074 char *kwnames[] = {
6075 (char *) "self",(char *) "pt", NULL
6076 };
6077
6078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6080 if (SWIG_arg_fail(1)) SWIG_fail;
6081 {
6082 arg2 = &temp2;
6083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6084 }
6085 {
6086 PyThreadState* __tstate = wxPyBeginAllowThreads();
6087 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6088
6089 wxPyEndAllowThreads(__tstate);
6090 if (PyErr_Occurred()) SWIG_fail;
6091 }
6092 {
6093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6094 }
6095 return resultobj;
6096 fail:
6097 return NULL;
6098 }
6099
6100
6101 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6102 PyObject *resultobj;
6103 wxRect *arg1 = (wxRect *) 0 ;
6104 wxRect *arg2 = 0 ;
6105 bool result;
6106 wxRect temp2 ;
6107 PyObject * obj0 = 0 ;
6108 PyObject * obj1 = 0 ;
6109 char *kwnames[] = {
6110 (char *) "self",(char *) "rect", NULL
6111 };
6112
6113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6115 if (SWIG_arg_fail(1)) SWIG_fail;
6116 {
6117 arg2 = &temp2;
6118 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6119 }
6120 {
6121 PyThreadState* __tstate = wxPyBeginAllowThreads();
6122 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6123
6124 wxPyEndAllowThreads(__tstate);
6125 if (PyErr_Occurred()) SWIG_fail;
6126 }
6127 {
6128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6129 }
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj;
6138 wxRect *arg1 = (wxRect *) 0 ;
6139 int arg2 ;
6140 PyObject * obj0 = 0 ;
6141 PyObject * obj1 = 0 ;
6142 char *kwnames[] = {
6143 (char *) "self",(char *) "x", NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 {
6150 arg2 = (int)(SWIG_As_int(obj1));
6151 if (SWIG_arg_fail(2)) SWIG_fail;
6152 }
6153 if (arg1) (arg1)->x = arg2;
6154
6155 Py_INCREF(Py_None); resultobj = Py_None;
6156 return resultobj;
6157 fail:
6158 return NULL;
6159 }
6160
6161
6162 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6163 PyObject *resultobj;
6164 wxRect *arg1 = (wxRect *) 0 ;
6165 int result;
6166 PyObject * obj0 = 0 ;
6167 char *kwnames[] = {
6168 (char *) "self", NULL
6169 };
6170
6171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6173 if (SWIG_arg_fail(1)) SWIG_fail;
6174 result = (int) ((arg1)->x);
6175
6176 {
6177 resultobj = SWIG_From_int((int)(result));
6178 }
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 int arg2 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "self",(char *) "y", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 {
6199 arg2 = (int)(SWIG_As_int(obj1));
6200 if (SWIG_arg_fail(2)) SWIG_fail;
6201 }
6202 if (arg1) (arg1)->y = arg2;
6203
6204 Py_INCREF(Py_None); resultobj = Py_None;
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 wxRect *arg1 = (wxRect *) 0 ;
6214 int result;
6215 PyObject * obj0 = 0 ;
6216 char *kwnames[] = {
6217 (char *) "self", NULL
6218 };
6219
6220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6222 if (SWIG_arg_fail(1)) SWIG_fail;
6223 result = (int) ((arg1)->y);
6224
6225 {
6226 resultobj = SWIG_From_int((int)(result));
6227 }
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int arg2 ;
6238 PyObject * obj0 = 0 ;
6239 PyObject * obj1 = 0 ;
6240 char *kwnames[] = {
6241 (char *) "self",(char *) "width", NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6246 if (SWIG_arg_fail(1)) SWIG_fail;
6247 {
6248 arg2 = (int)(SWIG_As_int(obj1));
6249 if (SWIG_arg_fail(2)) SWIG_fail;
6250 }
6251 if (arg1) (arg1)->width = arg2;
6252
6253 Py_INCREF(Py_None); resultobj = Py_None;
6254 return resultobj;
6255 fail:
6256 return NULL;
6257 }
6258
6259
6260 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6261 PyObject *resultobj;
6262 wxRect *arg1 = (wxRect *) 0 ;
6263 int result;
6264 PyObject * obj0 = 0 ;
6265 char *kwnames[] = {
6266 (char *) "self", NULL
6267 };
6268
6269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6271 if (SWIG_arg_fail(1)) SWIG_fail;
6272 result = (int) ((arg1)->width);
6273
6274 {
6275 resultobj = SWIG_From_int((int)(result));
6276 }
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj;
6285 wxRect *arg1 = (wxRect *) 0 ;
6286 int arg2 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "self",(char *) "height", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6295 if (SWIG_arg_fail(1)) SWIG_fail;
6296 {
6297 arg2 = (int)(SWIG_As_int(obj1));
6298 if (SWIG_arg_fail(2)) SWIG_fail;
6299 }
6300 if (arg1) (arg1)->height = arg2;
6301
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 wxRect *arg1 = (wxRect *) 0 ;
6312 int result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 result = (int) ((arg1)->height);
6322
6323 {
6324 resultobj = SWIG_From_int((int)(result));
6325 }
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj;
6334 wxRect *arg1 = (wxRect *) 0 ;
6335 int arg2 = (int) 0 ;
6336 int arg3 = (int) 0 ;
6337 int arg4 = (int) 0 ;
6338 int arg5 = (int) 0 ;
6339 PyObject * obj0 = 0 ;
6340 PyObject * obj1 = 0 ;
6341 PyObject * obj2 = 0 ;
6342 PyObject * obj3 = 0 ;
6343 PyObject * obj4 = 0 ;
6344 char *kwnames[] = {
6345 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6346 };
6347
6348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6350 if (SWIG_arg_fail(1)) SWIG_fail;
6351 if (obj1) {
6352 {
6353 arg2 = (int)(SWIG_As_int(obj1));
6354 if (SWIG_arg_fail(2)) SWIG_fail;
6355 }
6356 }
6357 if (obj2) {
6358 {
6359 arg3 = (int)(SWIG_As_int(obj2));
6360 if (SWIG_arg_fail(3)) SWIG_fail;
6361 }
6362 }
6363 if (obj3) {
6364 {
6365 arg4 = (int)(SWIG_As_int(obj3));
6366 if (SWIG_arg_fail(4)) SWIG_fail;
6367 }
6368 }
6369 if (obj4) {
6370 {
6371 arg5 = (int)(SWIG_As_int(obj4));
6372 if (SWIG_arg_fail(5)) SWIG_fail;
6373 }
6374 }
6375 {
6376 PyThreadState* __tstate = wxPyBeginAllowThreads();
6377 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6378
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 Py_INCREF(Py_None); resultobj = Py_None;
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6390 PyObject *resultobj;
6391 wxRect *arg1 = (wxRect *) 0 ;
6392 PyObject *result;
6393 PyObject * obj0 = 0 ;
6394 char *kwnames[] = {
6395 (char *) "self", NULL
6396 };
6397
6398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) 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 {
6402 PyThreadState* __tstate = wxPyBeginAllowThreads();
6403 result = (PyObject *)wxRect_Get(arg1);
6404
6405 wxPyEndAllowThreads(__tstate);
6406 if (PyErr_Occurred()) SWIG_fail;
6407 }
6408 resultobj = result;
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6416 PyObject *obj;
6417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6418 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6419 Py_INCREF(obj);
6420 return Py_BuildValue((char *)"");
6421 }
6422 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 wxRect *arg2 = (wxRect *) 0 ;
6426 PyObject *result;
6427 PyObject * obj0 = 0 ;
6428 PyObject * obj1 = 0 ;
6429 char *kwnames[] = {
6430 (char *) "r1",(char *) "r2", NULL
6431 };
6432
6433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6435 if (SWIG_arg_fail(1)) SWIG_fail;
6436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6437 if (SWIG_arg_fail(2)) SWIG_fail;
6438 {
6439 if (!wxPyCheckForApp()) SWIG_fail;
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (PyObject *)wxIntersectRect(arg1,arg2);
6442
6443 wxPyEndAllowThreads(__tstate);
6444 if (PyErr_Occurred()) SWIG_fail;
6445 }
6446 resultobj = result;
6447 return resultobj;
6448 fail:
6449 return NULL;
6450 }
6451
6452
6453 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6454 PyObject *resultobj;
6455 double arg1 = (double) 0.0 ;
6456 double arg2 = (double) 0.0 ;
6457 wxPoint2D *result;
6458 PyObject * obj0 = 0 ;
6459 PyObject * obj1 = 0 ;
6460 char *kwnames[] = {
6461 (char *) "x",(char *) "y", NULL
6462 };
6463
6464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6465 if (obj0) {
6466 {
6467 arg1 = (double)(SWIG_As_double(obj0));
6468 if (SWIG_arg_fail(1)) SWIG_fail;
6469 }
6470 }
6471 if (obj1) {
6472 {
6473 arg2 = (double)(SWIG_As_double(obj1));
6474 if (SWIG_arg_fail(2)) SWIG_fail;
6475 }
6476 }
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6480
6481 wxPyEndAllowThreads(__tstate);
6482 if (PyErr_Occurred()) SWIG_fail;
6483 }
6484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6485 return resultobj;
6486 fail:
6487 return NULL;
6488 }
6489
6490
6491 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6492 PyObject *resultobj;
6493 wxPoint2D *arg1 = 0 ;
6494 wxPoint2D *result;
6495 wxPoint2D temp1 ;
6496 PyObject * obj0 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "pt", NULL
6499 };
6500
6501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6502 {
6503 arg1 = &temp1;
6504 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6505 }
6506 {
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6509
6510 wxPyEndAllowThreads(__tstate);
6511 if (PyErr_Occurred()) SWIG_fail;
6512 }
6513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6514 return resultobj;
6515 fail:
6516 return NULL;
6517 }
6518
6519
6520 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6521 PyObject *resultobj;
6522 wxPoint *arg1 = 0 ;
6523 wxPoint2D *result;
6524 wxPoint temp1 ;
6525 PyObject * obj0 = 0 ;
6526 char *kwnames[] = {
6527 (char *) "pt", NULL
6528 };
6529
6530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6531 {
6532 arg1 = &temp1;
6533 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6534 }
6535 {
6536 PyThreadState* __tstate = wxPyBeginAllowThreads();
6537 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6538
6539 wxPyEndAllowThreads(__tstate);
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6543 return resultobj;
6544 fail:
6545 return NULL;
6546 }
6547
6548
6549 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6550 PyObject *resultobj;
6551 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6552 int *arg2 = (int *) 0 ;
6553 int *arg3 = (int *) 0 ;
6554 int temp2 ;
6555 int res2 = 0 ;
6556 int temp3 ;
6557 int res3 = 0 ;
6558 PyObject * obj0 = 0 ;
6559 char *kwnames[] = {
6560 (char *) "self", NULL
6561 };
6562
6563 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6564 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6567 if (SWIG_arg_fail(1)) SWIG_fail;
6568 {
6569 PyThreadState* __tstate = wxPyBeginAllowThreads();
6570 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6571
6572 wxPyEndAllowThreads(__tstate);
6573 if (PyErr_Occurred()) SWIG_fail;
6574 }
6575 Py_INCREF(Py_None); resultobj = Py_None;
6576 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6577 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6578 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6579 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6587 PyObject *resultobj;
6588 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6589 int *arg2 = (int *) 0 ;
6590 int *arg3 = (int *) 0 ;
6591 int temp2 ;
6592 int res2 = 0 ;
6593 int temp3 ;
6594 int res3 = 0 ;
6595 PyObject * obj0 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self", NULL
6598 };
6599
6600 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6601 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 Py_INCREF(Py_None); resultobj = Py_None;
6613 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6614 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6615 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6616 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj;
6625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6626 double result;
6627 PyObject * obj0 = 0 ;
6628 char *kwnames[] = {
6629 (char *) "self", NULL
6630 };
6631
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6634 if (SWIG_arg_fail(1)) SWIG_fail;
6635 {
6636 PyThreadState* __tstate = wxPyBeginAllowThreads();
6637 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6638
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 {
6643 resultobj = SWIG_From_double((double)(result));
6644 }
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj;
6653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6654 double result;
6655 PyObject * obj0 = 0 ;
6656 char *kwnames[] = {
6657 (char *) "self", NULL
6658 };
6659
6660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6662 if (SWIG_arg_fail(1)) SWIG_fail;
6663 {
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6666
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 {
6671 resultobj = SWIG_From_double((double)(result));
6672 }
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6682 double arg2 ;
6683 PyObject * obj0 = 0 ;
6684 PyObject * obj1 = 0 ;
6685 char *kwnames[] = {
6686 (char *) "self",(char *) "length", NULL
6687 };
6688
6689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6691 if (SWIG_arg_fail(1)) SWIG_fail;
6692 {
6693 arg2 = (double)(SWIG_As_double(obj1));
6694 if (SWIG_arg_fail(2)) SWIG_fail;
6695 }
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 (arg1)->SetVectorLength(arg2);
6699
6700 wxPyEndAllowThreads(__tstate);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 Py_INCREF(Py_None); resultobj = Py_None;
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6711 PyObject *resultobj;
6712 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6713 double arg2 ;
6714 PyObject * obj0 = 0 ;
6715 PyObject * obj1 = 0 ;
6716 char *kwnames[] = {
6717 (char *) "self",(char *) "degrees", NULL
6718 };
6719
6720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6722 if (SWIG_arg_fail(1)) SWIG_fail;
6723 {
6724 arg2 = (double)(SWIG_As_double(obj1));
6725 if (SWIG_arg_fail(2)) SWIG_fail;
6726 }
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 (arg1)->SetVectorAngle(arg2);
6730
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 Py_INCREF(Py_None); resultobj = Py_None;
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6744 wxPoint2D *arg2 = 0 ;
6745 double result;
6746 wxPoint2D temp2 ;
6747 PyObject * obj0 = 0 ;
6748 PyObject * obj1 = 0 ;
6749 char *kwnames[] = {
6750 (char *) "self",(char *) "pt", NULL
6751 };
6752
6753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6755 if (SWIG_arg_fail(1)) SWIG_fail;
6756 {
6757 arg2 = &temp2;
6758 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6759 }
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6763
6764 wxPyEndAllowThreads(__tstate);
6765 if (PyErr_Occurred()) SWIG_fail;
6766 }
6767 {
6768 resultobj = SWIG_From_double((double)(result));
6769 }
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj;
6778 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6779 wxPoint2D *arg2 = 0 ;
6780 double result;
6781 wxPoint2D temp2 ;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "pt", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 arg2 = &temp2;
6793 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6794 }
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6798
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 {
6803 resultobj = SWIG_From_double((double)(result));
6804 }
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6812 PyObject *resultobj;
6813 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6814 wxPoint2D *arg2 = 0 ;
6815 double result;
6816 wxPoint2D temp2 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char *kwnames[] = {
6820 (char *) "self",(char *) "vec", NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6825 if (SWIG_arg_fail(1)) SWIG_fail;
6826 {
6827 arg2 = &temp2;
6828 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6829 }
6830 {
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6833
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 {
6838 resultobj = SWIG_From_double((double)(result));
6839 }
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj;
6848 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6849 wxPoint2D *arg2 = 0 ;
6850 double result;
6851 wxPoint2D temp2 ;
6852 PyObject * obj0 = 0 ;
6853 PyObject * obj1 = 0 ;
6854 char *kwnames[] = {
6855 (char *) "self",(char *) "vec", NULL
6856 };
6857
6858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6860 if (SWIG_arg_fail(1)) SWIG_fail;
6861 {
6862 arg2 = &temp2;
6863 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6864 }
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 {
6873 resultobj = SWIG_From_double((double)(result));
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj;
6883 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6884 wxPoint2D result;
6885 PyObject * obj0 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (arg1)->operator -();
6896
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 {
6901 wxPoint2D * resultptr;
6902 resultptr = new wxPoint2D((wxPoint2D &)(result));
6903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6904 }
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6914 wxPoint2D *arg2 = 0 ;
6915 wxPoint2D *result;
6916 wxPoint2D temp2 ;
6917 PyObject * obj0 = 0 ;
6918 PyObject * obj1 = 0 ;
6919 char *kwnames[] = {
6920 (char *) "self",(char *) "pt", NULL
6921 };
6922
6923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6925 if (SWIG_arg_fail(1)) SWIG_fail;
6926 {
6927 arg2 = &temp2;
6928 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6929 }
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 {
6933 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6934 result = (wxPoint2D *) &_result_ref;
6935 }
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6948 PyObject *resultobj;
6949 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6950 wxPoint2D *arg2 = 0 ;
6951 wxPoint2D *result;
6952 wxPoint2D temp2 ;
6953 PyObject * obj0 = 0 ;
6954 PyObject * obj1 = 0 ;
6955 char *kwnames[] = {
6956 (char *) "self",(char *) "pt", NULL
6957 };
6958
6959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6961 if (SWIG_arg_fail(1)) SWIG_fail;
6962 {
6963 arg2 = &temp2;
6964 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6965 }
6966 {
6967 PyThreadState* __tstate = wxPyBeginAllowThreads();
6968 {
6969 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6970 result = (wxPoint2D *) &_result_ref;
6971 }
6972
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6984 PyObject *resultobj;
6985 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6986 wxPoint2D *arg2 = 0 ;
6987 wxPoint2D *result;
6988 wxPoint2D temp2 ;
6989 PyObject * obj0 = 0 ;
6990 PyObject * obj1 = 0 ;
6991 char *kwnames[] = {
6992 (char *) "self",(char *) "pt", NULL
6993 };
6994
6995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6997 if (SWIG_arg_fail(1)) SWIG_fail;
6998 {
6999 arg2 = &temp2;
7000 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7001 }
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 {
7005 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7006 result = (wxPoint2D *) &_result_ref;
7007 }
7008
7009 wxPyEndAllowThreads(__tstate);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7020 PyObject *resultobj;
7021 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7022 wxPoint2D *arg2 = 0 ;
7023 wxPoint2D *result;
7024 wxPoint2D temp2 ;
7025 PyObject * obj0 = 0 ;
7026 PyObject * obj1 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "self",(char *) "pt", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 {
7035 arg2 = &temp2;
7036 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7037 }
7038 {
7039 PyThreadState* __tstate = wxPyBeginAllowThreads();
7040 {
7041 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7042 result = (wxPoint2D *) &_result_ref;
7043 }
7044
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj;
7057 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7058 wxPoint2D *arg2 = 0 ;
7059 bool result;
7060 wxPoint2D temp2 ;
7061 PyObject * obj0 = 0 ;
7062 PyObject * obj1 = 0 ;
7063 char *kwnames[] = {
7064 (char *) "self",(char *) "pt", NULL
7065 };
7066
7067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7069 if (SWIG_arg_fail(1)) SWIG_fail;
7070 {
7071 arg2 = &temp2;
7072 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7073 }
7074 {
7075 PyThreadState* __tstate = wxPyBeginAllowThreads();
7076 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7077
7078 wxPyEndAllowThreads(__tstate);
7079 if (PyErr_Occurred()) SWIG_fail;
7080 }
7081 {
7082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7083 }
7084 return resultobj;
7085 fail:
7086 return NULL;
7087 }
7088
7089
7090 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7091 PyObject *resultobj;
7092 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7093 wxPoint2D *arg2 = 0 ;
7094 bool result;
7095 wxPoint2D temp2 ;
7096 PyObject * obj0 = 0 ;
7097 PyObject * obj1 = 0 ;
7098 char *kwnames[] = {
7099 (char *) "self",(char *) "pt", NULL
7100 };
7101
7102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7104 if (SWIG_arg_fail(1)) SWIG_fail;
7105 {
7106 arg2 = &temp2;
7107 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7108 }
7109 {
7110 PyThreadState* __tstate = wxPyBeginAllowThreads();
7111 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7112
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 {
7117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7118 }
7119 return resultobj;
7120 fail:
7121 return NULL;
7122 }
7123
7124
7125 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7126 PyObject *resultobj;
7127 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7128 double arg2 ;
7129 PyObject * obj0 = 0 ;
7130 PyObject * obj1 = 0 ;
7131 char *kwnames[] = {
7132 (char *) "self",(char *) "m_x", NULL
7133 };
7134
7135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7137 if (SWIG_arg_fail(1)) SWIG_fail;
7138 {
7139 arg2 = (double)(SWIG_As_double(obj1));
7140 if (SWIG_arg_fail(2)) SWIG_fail;
7141 }
7142 if (arg1) (arg1)->m_x = arg2;
7143
7144 Py_INCREF(Py_None); resultobj = Py_None;
7145 return resultobj;
7146 fail:
7147 return NULL;
7148 }
7149
7150
7151 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7152 PyObject *resultobj;
7153 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7154 double result;
7155 PyObject * obj0 = 0 ;
7156 char *kwnames[] = {
7157 (char *) "self", NULL
7158 };
7159
7160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7162 if (SWIG_arg_fail(1)) SWIG_fail;
7163 result = (double) ((arg1)->m_x);
7164
7165 {
7166 resultobj = SWIG_From_double((double)(result));
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7177 double arg2 ;
7178 PyObject * obj0 = 0 ;
7179 PyObject * obj1 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self",(char *) "m_y", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 arg2 = (double)(SWIG_As_double(obj1));
7189 if (SWIG_arg_fail(2)) SWIG_fail;
7190 }
7191 if (arg1) (arg1)->m_y = arg2;
7192
7193 Py_INCREF(Py_None); resultobj = Py_None;
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj;
7202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7203 double result;
7204 PyObject * obj0 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 result = (double) ((arg1)->m_y);
7213
7214 {
7215 resultobj = SWIG_From_double((double)(result));
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj;
7225 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7226 double arg2 = (double) 0 ;
7227 double arg3 = (double) 0 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 PyObject * obj2 = 0 ;
7231 char *kwnames[] = {
7232 (char *) "self",(char *) "x",(char *) "y", NULL
7233 };
7234
7235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7237 if (SWIG_arg_fail(1)) SWIG_fail;
7238 if (obj1) {
7239 {
7240 arg2 = (double)(SWIG_As_double(obj1));
7241 if (SWIG_arg_fail(2)) SWIG_fail;
7242 }
7243 }
7244 if (obj2) {
7245 {
7246 arg3 = (double)(SWIG_As_double(obj2));
7247 if (SWIG_arg_fail(3)) SWIG_fail;
7248 }
7249 }
7250 {
7251 PyThreadState* __tstate = wxPyBeginAllowThreads();
7252 wxPoint2D_Set(arg1,arg2,arg3);
7253
7254 wxPyEndAllowThreads(__tstate);
7255 if (PyErr_Occurred()) SWIG_fail;
7256 }
7257 Py_INCREF(Py_None); resultobj = Py_None;
7258 return resultobj;
7259 fail:
7260 return NULL;
7261 }
7262
7263
7264 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7265 PyObject *resultobj;
7266 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7267 PyObject *result;
7268 PyObject * obj0 = 0 ;
7269 char *kwnames[] = {
7270 (char *) "self", NULL
7271 };
7272
7273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7275 if (SWIG_arg_fail(1)) SWIG_fail;
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (PyObject *)wxPoint2D_Get(arg1);
7279
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 resultobj = result;
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7291 PyObject *obj;
7292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7293 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7294 Py_INCREF(obj);
7295 return Py_BuildValue((char *)"");
7296 }
7297 static int _wrap_DefaultPosition_set(PyObject *) {
7298 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7299 return 1;
7300 }
7301
7302
7303 static PyObject *_wrap_DefaultPosition_get(void) {
7304 PyObject *pyobj;
7305
7306 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7307 return pyobj;
7308 }
7309
7310
7311 static int _wrap_DefaultSize_set(PyObject *) {
7312 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7313 return 1;
7314 }
7315
7316
7317 static PyObject *_wrap_DefaultSize_get(void) {
7318 PyObject *pyobj;
7319
7320 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7321 return pyobj;
7322 }
7323
7324
7325 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7326 PyObject *resultobj;
7327 PyObject *arg1 = (PyObject *) 0 ;
7328 wxPyInputStream *result;
7329 PyObject * obj0 = 0 ;
7330 char *kwnames[] = {
7331 (char *) "p", NULL
7332 };
7333
7334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7335 arg1 = obj0;
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7339
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj;
7352 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7353 PyObject * obj0 = 0 ;
7354 char *kwnames[] = {
7355 (char *) "self", NULL
7356 };
7357
7358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7360 if (SWIG_arg_fail(1)) SWIG_fail;
7361 {
7362 PyThreadState* __tstate = wxPyBeginAllowThreads();
7363 delete arg1;
7364
7365 wxPyEndAllowThreads(__tstate);
7366 if (PyErr_Occurred()) SWIG_fail;
7367 }
7368 Py_INCREF(Py_None); resultobj = Py_None;
7369 return resultobj;
7370 fail:
7371 return NULL;
7372 }
7373
7374
7375 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7376 PyObject *resultobj;
7377 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7378 PyObject * obj0 = 0 ;
7379 char *kwnames[] = {
7380 (char *) "self", NULL
7381 };
7382
7383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7385 if (SWIG_arg_fail(1)) SWIG_fail;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 (arg1)->close();
7389
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 Py_INCREF(Py_None); resultobj = Py_None;
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_InputStream_flush(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:InputStream_flush",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 (arg1)->flush();
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_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7428 bool result;
7429 PyObject * obj0 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->eof();
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7456 int arg2 = (int) -1 ;
7457 PyObject *result;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 char *kwnames[] = {
7461 (char *) "self",(char *) "size", NULL
7462 };
7463
7464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(1)) SWIG_fail;
7467 if (obj1) {
7468 {
7469 arg2 = (int)(SWIG_As_int(obj1));
7470 if (SWIG_arg_fail(2)) SWIG_fail;
7471 }
7472 }
7473 {
7474 PyThreadState* __tstate = wxPyBeginAllowThreads();
7475 result = (PyObject *)(arg1)->read(arg2);
7476
7477 wxPyEndAllowThreads(__tstate);
7478 if (PyErr_Occurred()) SWIG_fail;
7479 }
7480 resultobj = result;
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj;
7489 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7490 int arg2 = (int) -1 ;
7491 PyObject *result;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char *kwnames[] = {
7495 (char *) "self",(char *) "size", NULL
7496 };
7497
7498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7500 if (SWIG_arg_fail(1)) SWIG_fail;
7501 if (obj1) {
7502 {
7503 arg2 = (int)(SWIG_As_int(obj1));
7504 if (SWIG_arg_fail(2)) SWIG_fail;
7505 }
7506 }
7507 {
7508 PyThreadState* __tstate = wxPyBeginAllowThreads();
7509 result = (PyObject *)(arg1)->readline(arg2);
7510
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 resultobj = result;
7515 return resultobj;
7516 fail:
7517 return NULL;
7518 }
7519
7520
7521 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7522 PyObject *resultobj;
7523 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7524 int arg2 = (int) -1 ;
7525 PyObject *result;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "self",(char *) "sizehint", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(1)) SWIG_fail;
7535 if (obj1) {
7536 {
7537 arg2 = (int)(SWIG_As_int(obj1));
7538 if (SWIG_arg_fail(2)) SWIG_fail;
7539 }
7540 }
7541 {
7542 PyThreadState* __tstate = wxPyBeginAllowThreads();
7543 result = (PyObject *)(arg1)->readlines(arg2);
7544
7545 wxPyEndAllowThreads(__tstate);
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 resultobj = result;
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj;
7557 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7558 int arg2 ;
7559 int arg3 = (int) 0 ;
7560 PyObject * obj0 = 0 ;
7561 PyObject * obj1 = 0 ;
7562 PyObject * obj2 = 0 ;
7563 char *kwnames[] = {
7564 (char *) "self",(char *) "offset",(char *) "whence", NULL
7565 };
7566
7567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7569 if (SWIG_arg_fail(1)) SWIG_fail;
7570 {
7571 arg2 = (int)(SWIG_As_int(obj1));
7572 if (SWIG_arg_fail(2)) SWIG_fail;
7573 }
7574 if (obj2) {
7575 {
7576 arg3 = (int)(SWIG_As_int(obj2));
7577 if (SWIG_arg_fail(3)) SWIG_fail;
7578 }
7579 }
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 (arg1)->seek(arg2,arg3);
7583
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 Py_INCREF(Py_None); resultobj = Py_None;
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj;
7596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7597 int result;
7598 PyObject * obj0 = 0 ;
7599 char *kwnames[] = {
7600 (char *) "self", NULL
7601 };
7602
7603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7605 if (SWIG_arg_fail(1)) SWIG_fail;
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (int)(arg1)->tell();
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = SWIG_From_int((int)(result));
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 char result;
7626 PyObject * obj0 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7633 if (SWIG_arg_fail(1)) SWIG_fail;
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 result = (char)(arg1)->Peek();
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = SWIG_From_char((char)(result));
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7653 char result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7661 if (SWIG_arg_fail(1)) SWIG_fail;
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (char)(arg1)->GetC();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 resultobj = SWIG_From_char((char)(result));
7671 }
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 size_t result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (size_t)(arg1)->LastRead();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 bool result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (bool)(arg1)->CanRead();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 bool result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (bool)(arg1)->Eof();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7765 char arg2 ;
7766 bool result;
7767 PyObject * obj0 = 0 ;
7768 PyObject * obj1 = 0 ;
7769 char *kwnames[] = {
7770 (char *) "self",(char *) "c", NULL
7771 };
7772
7773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7775 if (SWIG_arg_fail(1)) SWIG_fail;
7776 {
7777 arg2 = (char)(SWIG_As_char(obj1));
7778 if (SWIG_arg_fail(2)) SWIG_fail;
7779 }
7780 {
7781 PyThreadState* __tstate = wxPyBeginAllowThreads();
7782 result = (bool)(arg1)->Ungetch(arg2);
7783
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 {
7788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7789 }
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj;
7798 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7799 long arg2 ;
7800 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7801 long result;
7802 PyObject * obj0 = 0 ;
7803 PyObject * obj1 = 0 ;
7804 PyObject * obj2 = 0 ;
7805 char *kwnames[] = {
7806 (char *) "self",(char *) "pos",(char *) "mode", NULL
7807 };
7808
7809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7811 if (SWIG_arg_fail(1)) SWIG_fail;
7812 {
7813 arg2 = (long)(SWIG_As_long(obj1));
7814 if (SWIG_arg_fail(2)) SWIG_fail;
7815 }
7816 if (obj2) {
7817 {
7818 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7819 if (SWIG_arg_fail(3)) SWIG_fail;
7820 }
7821 }
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 {
7830 resultobj = SWIG_From_long((long)(result));
7831 }
7832 return resultobj;
7833 fail:
7834 return NULL;
7835 }
7836
7837
7838 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7839 PyObject *resultobj;
7840 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7841 long result;
7842 PyObject * obj0 = 0 ;
7843 char *kwnames[] = {
7844 (char *) "self", NULL
7845 };
7846
7847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7849 if (SWIG_arg_fail(1)) SWIG_fail;
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = (long)(arg1)->TellI();
7853
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 {
7858 resultobj = SWIG_From_long((long)(result));
7859 }
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7867 PyObject *obj;
7868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7869 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7870 Py_INCREF(obj);
7871 return Py_BuildValue((char *)"");
7872 }
7873 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj;
7875 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7876 PyObject *arg2 = (PyObject *) 0 ;
7877 PyObject * obj0 = 0 ;
7878 PyObject * obj1 = 0 ;
7879 char *kwnames[] = {
7880 (char *) "self",(char *) "obj", NULL
7881 };
7882
7883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7885 if (SWIG_arg_fail(1)) SWIG_fail;
7886 arg2 = obj1;
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 wxOutputStream_write(arg1,arg2);
7890
7891 wxPyEndAllowThreads(__tstate);
7892 if (PyErr_Occurred()) SWIG_fail;
7893 }
7894 Py_INCREF(Py_None); resultobj = Py_None;
7895 return resultobj;
7896 fail:
7897 return NULL;
7898 }
7899
7900
7901 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7902 PyObject *obj;
7903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7904 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7905 Py_INCREF(obj);
7906 return Py_BuildValue((char *)"");
7907 }
7908 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7909 PyObject *resultobj;
7910 wxInputStream *arg1 = (wxInputStream *) 0 ;
7911 wxString *arg2 = 0 ;
7912 wxString *arg3 = 0 ;
7913 wxString *arg4 = 0 ;
7914 wxDateTime arg5 ;
7915 wxFSFile *result;
7916 wxPyInputStream *temp1 ;
7917 bool temp2 = false ;
7918 bool temp3 = false ;
7919 bool temp4 = false ;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 PyObject * obj2 = 0 ;
7923 PyObject * obj3 = 0 ;
7924 PyObject * obj4 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7930 {
7931 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7932 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7933 } else {
7934 PyErr_Clear(); // clear the failure of the wxPyConvert above
7935 arg1 = wxPyCBInputStream_create(obj0, true);
7936 if (arg1 == NULL) {
7937 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7938 SWIG_fail;
7939 }
7940 }
7941 }
7942 {
7943 arg2 = wxString_in_helper(obj1);
7944 if (arg2 == NULL) SWIG_fail;
7945 temp2 = true;
7946 }
7947 {
7948 arg3 = wxString_in_helper(obj2);
7949 if (arg3 == NULL) SWIG_fail;
7950 temp3 = true;
7951 }
7952 {
7953 arg4 = wxString_in_helper(obj3);
7954 if (arg4 == NULL) SWIG_fail;
7955 temp4 = true;
7956 }
7957 {
7958 wxDateTime * argp;
7959 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7960 if (SWIG_arg_fail(5)) SWIG_fail;
7961 if (argp == NULL) {
7962 SWIG_null_ref("wxDateTime");
7963 }
7964 if (SWIG_arg_fail(5)) SWIG_fail;
7965 arg5 = *argp;
7966 }
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7970
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 {
7975 resultobj = wxPyMake_wxObject(result, 1);
7976 }
7977 {
7978 if (temp2)
7979 delete arg2;
7980 }
7981 {
7982 if (temp3)
7983 delete arg3;
7984 }
7985 {
7986 if (temp4)
7987 delete arg4;
7988 }
7989 return resultobj;
7990 fail:
7991 {
7992 if (temp2)
7993 delete arg2;
7994 }
7995 {
7996 if (temp3)
7997 delete arg3;
7998 }
7999 {
8000 if (temp4)
8001 delete arg4;
8002 }
8003 return NULL;
8004 }
8005
8006
8007 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8008 PyObject *resultobj;
8009 wxFSFile *arg1 = (wxFSFile *) 0 ;
8010 PyObject * obj0 = 0 ;
8011 char *kwnames[] = {
8012 (char *) "self", NULL
8013 };
8014
8015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8017 if (SWIG_arg_fail(1)) SWIG_fail;
8018 {
8019 PyThreadState* __tstate = wxPyBeginAllowThreads();
8020 delete arg1;
8021
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 Py_INCREF(Py_None); resultobj = Py_None;
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj;
8034 wxFSFile *arg1 = (wxFSFile *) 0 ;
8035 wxInputStream *result;
8036 PyObject * obj0 = 0 ;
8037 char *kwnames[] = {
8038 (char *) "self", NULL
8039 };
8040
8041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8043 if (SWIG_arg_fail(1)) SWIG_fail;
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (wxInputStream *)(arg1)->GetStream();
8047
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 {
8052 wxPyInputStream * _ptr = NULL;
8053
8054 if (result) {
8055 _ptr = new wxPyInputStream(result);
8056 }
8057 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8058 }
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8066 PyObject *resultobj;
8067 wxFSFile *arg1 = (wxFSFile *) 0 ;
8068 wxString *result;
8069 PyObject * obj0 = 0 ;
8070 char *kwnames[] = {
8071 (char *) "self", NULL
8072 };
8073
8074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8076 if (SWIG_arg_fail(1)) SWIG_fail;
8077 {
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 {
8080 wxString const &_result_ref = (arg1)->GetMimeType();
8081 result = (wxString *) &_result_ref;
8082 }
8083
8084 wxPyEndAllowThreads(__tstate);
8085 if (PyErr_Occurred()) SWIG_fail;
8086 }
8087 {
8088 #if wxUSE_UNICODE
8089 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8090 #else
8091 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8092 #endif
8093 }
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj;
8102 wxFSFile *arg1 = (wxFSFile *) 0 ;
8103 wxString *result;
8104 PyObject * obj0 = 0 ;
8105 char *kwnames[] = {
8106 (char *) "self", NULL
8107 };
8108
8109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8111 if (SWIG_arg_fail(1)) SWIG_fail;
8112 {
8113 PyThreadState* __tstate = wxPyBeginAllowThreads();
8114 {
8115 wxString const &_result_ref = (arg1)->GetLocation();
8116 result = (wxString *) &_result_ref;
8117 }
8118
8119 wxPyEndAllowThreads(__tstate);
8120 if (PyErr_Occurred()) SWIG_fail;
8121 }
8122 {
8123 #if wxUSE_UNICODE
8124 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8125 #else
8126 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8127 #endif
8128 }
8129 return resultobj;
8130 fail:
8131 return NULL;
8132 }
8133
8134
8135 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8136 PyObject *resultobj;
8137 wxFSFile *arg1 = (wxFSFile *) 0 ;
8138 wxString *result;
8139 PyObject * obj0 = 0 ;
8140 char *kwnames[] = {
8141 (char *) "self", NULL
8142 };
8143
8144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8146 if (SWIG_arg_fail(1)) SWIG_fail;
8147 {
8148 PyThreadState* __tstate = wxPyBeginAllowThreads();
8149 {
8150 wxString const &_result_ref = (arg1)->GetAnchor();
8151 result = (wxString *) &_result_ref;
8152 }
8153
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 {
8158 #if wxUSE_UNICODE
8159 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8160 #else
8161 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8162 #endif
8163 }
8164 return resultobj;
8165 fail:
8166 return NULL;
8167 }
8168
8169
8170 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8171 PyObject *resultobj;
8172 wxFSFile *arg1 = (wxFSFile *) 0 ;
8173 wxDateTime result;
8174 PyObject * obj0 = 0 ;
8175 char *kwnames[] = {
8176 (char *) "self", NULL
8177 };
8178
8179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8181 if (SWIG_arg_fail(1)) SWIG_fail;
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (arg1)->GetModificationTime();
8185
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 {
8190 wxDateTime * resultptr;
8191 resultptr = new wxDateTime((wxDateTime &)(result));
8192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8193 }
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8201 PyObject *obj;
8202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8203 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8204 Py_INCREF(obj);
8205 return Py_BuildValue((char *)"");
8206 }
8207 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8208 PyObject *obj;
8209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8210 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8211 Py_INCREF(obj);
8212 return Py_BuildValue((char *)"");
8213 }
8214 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8215 PyObject *resultobj;
8216 wxPyFileSystemHandler *result;
8217 char *kwnames[] = {
8218 NULL
8219 };
8220
8221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8222 {
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8225
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8230 return resultobj;
8231 fail:
8232 return NULL;
8233 }
8234
8235
8236 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8237 PyObject *resultobj;
8238 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8239 PyObject *arg2 = (PyObject *) 0 ;
8240 PyObject *arg3 = (PyObject *) 0 ;
8241 PyObject * obj0 = 0 ;
8242 PyObject * obj1 = 0 ;
8243 PyObject * obj2 = 0 ;
8244 char *kwnames[] = {
8245 (char *) "self",(char *) "self",(char *) "_class", NULL
8246 };
8247
8248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8250 if (SWIG_arg_fail(1)) SWIG_fail;
8251 arg2 = obj1;
8252 arg3 = obj2;
8253 {
8254 PyThreadState* __tstate = wxPyBeginAllowThreads();
8255 (arg1)->_setCallbackInfo(arg2,arg3);
8256
8257 wxPyEndAllowThreads(__tstate);
8258 if (PyErr_Occurred()) SWIG_fail;
8259 }
8260 Py_INCREF(Py_None); resultobj = Py_None;
8261 return resultobj;
8262 fail:
8263 return NULL;
8264 }
8265
8266
8267 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8268 PyObject *resultobj;
8269 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8270 wxString *arg2 = 0 ;
8271 bool result;
8272 bool temp2 = false ;
8273 PyObject * obj0 = 0 ;
8274 PyObject * obj1 = 0 ;
8275 char *kwnames[] = {
8276 (char *) "self",(char *) "location", NULL
8277 };
8278
8279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8281 if (SWIG_arg_fail(1)) SWIG_fail;
8282 {
8283 arg2 = wxString_in_helper(obj1);
8284 if (arg2 == NULL) SWIG_fail;
8285 temp2 = true;
8286 }
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8290
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 {
8295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8296 }
8297 {
8298 if (temp2)
8299 delete arg2;
8300 }
8301 return resultobj;
8302 fail:
8303 {
8304 if (temp2)
8305 delete arg2;
8306 }
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8314 wxFileSystem *arg2 = 0 ;
8315 wxString *arg3 = 0 ;
8316 wxFSFile *result;
8317 bool temp3 = false ;
8318 PyObject * obj0 = 0 ;
8319 PyObject * obj1 = 0 ;
8320 PyObject * obj2 = 0 ;
8321 char *kwnames[] = {
8322 (char *) "self",(char *) "fs",(char *) "location", NULL
8323 };
8324
8325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8327 if (SWIG_arg_fail(1)) SWIG_fail;
8328 {
8329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(2)) SWIG_fail;
8331 if (arg2 == NULL) {
8332 SWIG_null_ref("wxFileSystem");
8333 }
8334 if (SWIG_arg_fail(2)) SWIG_fail;
8335 }
8336 {
8337 arg3 = wxString_in_helper(obj2);
8338 if (arg3 == NULL) SWIG_fail;
8339 temp3 = true;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8344
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 {
8349 resultobj = wxPyMake_wxObject(result, 1);
8350 }
8351 {
8352 if (temp3)
8353 delete arg3;
8354 }
8355 return resultobj;
8356 fail:
8357 {
8358 if (temp3)
8359 delete arg3;
8360 }
8361 return NULL;
8362 }
8363
8364
8365 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj;
8367 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8368 wxString *arg2 = 0 ;
8369 int arg3 = (int) 0 ;
8370 wxString result;
8371 bool temp2 = false ;
8372 PyObject * obj0 = 0 ;
8373 PyObject * obj1 = 0 ;
8374 PyObject * obj2 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self",(char *) "spec",(char *) "flags", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 {
8383 arg2 = wxString_in_helper(obj1);
8384 if (arg2 == NULL) SWIG_fail;
8385 temp2 = true;
8386 }
8387 if (obj2) {
8388 {
8389 arg3 = (int)(SWIG_As_int(obj2));
8390 if (SWIG_arg_fail(3)) SWIG_fail;
8391 }
8392 }
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8396
8397 wxPyEndAllowThreads(__tstate);
8398 if (PyErr_Occurred()) SWIG_fail;
8399 }
8400 {
8401 #if wxUSE_UNICODE
8402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8403 #else
8404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8405 #endif
8406 }
8407 {
8408 if (temp2)
8409 delete arg2;
8410 }
8411 return resultobj;
8412 fail:
8413 {
8414 if (temp2)
8415 delete arg2;
8416 }
8417 return NULL;
8418 }
8419
8420
8421 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj;
8423 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8424 wxString result;
8425 PyObject * obj0 = 0 ;
8426 char *kwnames[] = {
8427 (char *) "self", NULL
8428 };
8429
8430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8432 if (SWIG_arg_fail(1)) SWIG_fail;
8433 {
8434 PyThreadState* __tstate = wxPyBeginAllowThreads();
8435 result = (arg1)->FindNext();
8436
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 {
8441 #if wxUSE_UNICODE
8442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8443 #else
8444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8445 #endif
8446 }
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8454 PyObject *resultobj;
8455 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8456 wxString *arg2 = 0 ;
8457 wxString result;
8458 bool temp2 = false ;
8459 PyObject * obj0 = 0 ;
8460 PyObject * obj1 = 0 ;
8461 char *kwnames[] = {
8462 (char *) "self",(char *) "location", NULL
8463 };
8464
8465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8467 if (SWIG_arg_fail(1)) SWIG_fail;
8468 {
8469 arg2 = wxString_in_helper(obj1);
8470 if (arg2 == NULL) SWIG_fail;
8471 temp2 = true;
8472 }
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 result = (arg1)->GetProtocol((wxString const &)*arg2);
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 {
8481 #if wxUSE_UNICODE
8482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8483 #else
8484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8485 #endif
8486 }
8487 {
8488 if (temp2)
8489 delete arg2;
8490 }
8491 return resultobj;
8492 fail:
8493 {
8494 if (temp2)
8495 delete arg2;
8496 }
8497 return NULL;
8498 }
8499
8500
8501 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8502 PyObject *resultobj;
8503 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8504 wxString *arg2 = 0 ;
8505 wxString result;
8506 bool temp2 = false ;
8507 PyObject * obj0 = 0 ;
8508 PyObject * obj1 = 0 ;
8509 char *kwnames[] = {
8510 (char *) "self",(char *) "location", NULL
8511 };
8512
8513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8515 if (SWIG_arg_fail(1)) SWIG_fail;
8516 {
8517 arg2 = wxString_in_helper(obj1);
8518 if (arg2 == NULL) SWIG_fail;
8519 temp2 = true;
8520 }
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8524
8525 wxPyEndAllowThreads(__tstate);
8526 if (PyErr_Occurred()) SWIG_fail;
8527 }
8528 {
8529 #if wxUSE_UNICODE
8530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8531 #else
8532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8533 #endif
8534 }
8535 {
8536 if (temp2)
8537 delete arg2;
8538 }
8539 return resultobj;
8540 fail:
8541 {
8542 if (temp2)
8543 delete arg2;
8544 }
8545 return NULL;
8546 }
8547
8548
8549 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8550 PyObject *resultobj;
8551 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8552 wxString *arg2 = 0 ;
8553 wxString result;
8554 bool temp2 = false ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 char *kwnames[] = {
8558 (char *) "self",(char *) "location", NULL
8559 };
8560
8561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8563 if (SWIG_arg_fail(1)) SWIG_fail;
8564 {
8565 arg2 = wxString_in_helper(obj1);
8566 if (arg2 == NULL) SWIG_fail;
8567 temp2 = true;
8568 }
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 result = (arg1)->GetAnchor((wxString const &)*arg2);
8572
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 {
8577 #if wxUSE_UNICODE
8578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8579 #else
8580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8581 #endif
8582 }
8583 {
8584 if (temp2)
8585 delete arg2;
8586 }
8587 return resultobj;
8588 fail:
8589 {
8590 if (temp2)
8591 delete arg2;
8592 }
8593 return NULL;
8594 }
8595
8596
8597 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj;
8599 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8600 wxString *arg2 = 0 ;
8601 wxString result;
8602 bool temp2 = false ;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char *kwnames[] = {
8606 (char *) "self",(char *) "location", NULL
8607 };
8608
8609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8611 if (SWIG_arg_fail(1)) SWIG_fail;
8612 {
8613 arg2 = wxString_in_helper(obj1);
8614 if (arg2 == NULL) SWIG_fail;
8615 temp2 = true;
8616 }
8617 {
8618 PyThreadState* __tstate = wxPyBeginAllowThreads();
8619 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8620
8621 wxPyEndAllowThreads(__tstate);
8622 if (PyErr_Occurred()) SWIG_fail;
8623 }
8624 {
8625 #if wxUSE_UNICODE
8626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8627 #else
8628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8629 #endif
8630 }
8631 {
8632 if (temp2)
8633 delete arg2;
8634 }
8635 return resultobj;
8636 fail:
8637 {
8638 if (temp2)
8639 delete arg2;
8640 }
8641 return NULL;
8642 }
8643
8644
8645 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj;
8647 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8648 wxString *arg2 = 0 ;
8649 wxString result;
8650 bool temp2 = false ;
8651 PyObject * obj0 = 0 ;
8652 PyObject * obj1 = 0 ;
8653 char *kwnames[] = {
8654 (char *) "self",(char *) "location", NULL
8655 };
8656
8657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8659 if (SWIG_arg_fail(1)) SWIG_fail;
8660 {
8661 arg2 = wxString_in_helper(obj1);
8662 if (arg2 == NULL) SWIG_fail;
8663 temp2 = true;
8664 }
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8668
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 {
8673 #if wxUSE_UNICODE
8674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8675 #else
8676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8677 #endif
8678 }
8679 {
8680 if (temp2)
8681 delete arg2;
8682 }
8683 return resultobj;
8684 fail:
8685 {
8686 if (temp2)
8687 delete arg2;
8688 }
8689 return NULL;
8690 }
8691
8692
8693 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8694 PyObject *obj;
8695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8696 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8697 Py_INCREF(obj);
8698 return Py_BuildValue((char *)"");
8699 }
8700 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8701 PyObject *resultobj;
8702 wxFileSystem *result;
8703 char *kwnames[] = {
8704 NULL
8705 };
8706
8707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8708 {
8709 PyThreadState* __tstate = wxPyBeginAllowThreads();
8710 result = (wxFileSystem *)new wxFileSystem();
8711
8712 wxPyEndAllowThreads(__tstate);
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 {
8716 resultobj = wxPyMake_wxObject(result, 1);
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8725 PyObject *resultobj;
8726 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8727 PyObject * obj0 = 0 ;
8728 char *kwnames[] = {
8729 (char *) "self", NULL
8730 };
8731
8732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8734 if (SWIG_arg_fail(1)) SWIG_fail;
8735 {
8736 PyThreadState* __tstate = wxPyBeginAllowThreads();
8737 delete arg1;
8738
8739 wxPyEndAllowThreads(__tstate);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 Py_INCREF(Py_None); resultobj = Py_None;
8743 return resultobj;
8744 fail:
8745 return NULL;
8746 }
8747
8748
8749 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8750 PyObject *resultobj;
8751 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8752 wxString *arg2 = 0 ;
8753 bool arg3 = (bool) false ;
8754 bool temp2 = false ;
8755 PyObject * obj0 = 0 ;
8756 PyObject * obj1 = 0 ;
8757 PyObject * obj2 = 0 ;
8758 char *kwnames[] = {
8759 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8760 };
8761
8762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8764 if (SWIG_arg_fail(1)) SWIG_fail;
8765 {
8766 arg2 = wxString_in_helper(obj1);
8767 if (arg2 == NULL) SWIG_fail;
8768 temp2 = true;
8769 }
8770 if (obj2) {
8771 {
8772 arg3 = (bool)(SWIG_As_bool(obj2));
8773 if (SWIG_arg_fail(3)) SWIG_fail;
8774 }
8775 }
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8779
8780 wxPyEndAllowThreads(__tstate);
8781 if (PyErr_Occurred()) SWIG_fail;
8782 }
8783 Py_INCREF(Py_None); resultobj = Py_None;
8784 {
8785 if (temp2)
8786 delete arg2;
8787 }
8788 return resultobj;
8789 fail:
8790 {
8791 if (temp2)
8792 delete arg2;
8793 }
8794 return NULL;
8795 }
8796
8797
8798 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj;
8800 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8801 wxString result;
8802 PyObject * obj0 = 0 ;
8803 char *kwnames[] = {
8804 (char *) "self", NULL
8805 };
8806
8807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8809 if (SWIG_arg_fail(1)) SWIG_fail;
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 result = (arg1)->GetPath();
8813
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 {
8818 #if wxUSE_UNICODE
8819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8820 #else
8821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8822 #endif
8823 }
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj;
8832 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8833 wxString *arg2 = 0 ;
8834 wxFSFile *result;
8835 bool temp2 = false ;
8836 PyObject * obj0 = 0 ;
8837 PyObject * obj1 = 0 ;
8838 char *kwnames[] = {
8839 (char *) "self",(char *) "location", NULL
8840 };
8841
8842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8844 if (SWIG_arg_fail(1)) SWIG_fail;
8845 {
8846 arg2 = wxString_in_helper(obj1);
8847 if (arg2 == NULL) SWIG_fail;
8848 temp2 = true;
8849 }
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8853
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 {
8858 resultobj = wxPyMake_wxObject(result, 1);
8859 }
8860 {
8861 if (temp2)
8862 delete arg2;
8863 }
8864 return resultobj;
8865 fail:
8866 {
8867 if (temp2)
8868 delete arg2;
8869 }
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8877 wxString *arg2 = 0 ;
8878 int arg3 = (int) 0 ;
8879 wxString result;
8880 bool temp2 = false ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 PyObject * obj2 = 0 ;
8884 char *kwnames[] = {
8885 (char *) "self",(char *) "spec",(char *) "flags", NULL
8886 };
8887
8888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8890 if (SWIG_arg_fail(1)) SWIG_fail;
8891 {
8892 arg2 = wxString_in_helper(obj1);
8893 if (arg2 == NULL) SWIG_fail;
8894 temp2 = true;
8895 }
8896 if (obj2) {
8897 {
8898 arg3 = (int)(SWIG_As_int(obj2));
8899 if (SWIG_arg_fail(3)) SWIG_fail;
8900 }
8901 }
8902 {
8903 PyThreadState* __tstate = wxPyBeginAllowThreads();
8904 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8905
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 {
8910 #if wxUSE_UNICODE
8911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8912 #else
8913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8914 #endif
8915 }
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return resultobj;
8921 fail:
8922 {
8923 if (temp2)
8924 delete arg2;
8925 }
8926 return NULL;
8927 }
8928
8929
8930 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj;
8932 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8933 wxString result;
8934 PyObject * obj0 = 0 ;
8935 char *kwnames[] = {
8936 (char *) "self", NULL
8937 };
8938
8939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8941 if (SWIG_arg_fail(1)) SWIG_fail;
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 result = (arg1)->FindNext();
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 {
8950 #if wxUSE_UNICODE
8951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8952 #else
8953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8954 #endif
8955 }
8956 return resultobj;
8957 fail:
8958 return NULL;
8959 }
8960
8961
8962 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj;
8964 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8965 PyObject * obj0 = 0 ;
8966 char *kwnames[] = {
8967 (char *) "handler", NULL
8968 };
8969
8970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8972 if (SWIG_arg_fail(1)) SWIG_fail;
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 wxFileSystem::AddHandler(arg1);
8976
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 Py_INCREF(Py_None); resultobj = Py_None;
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8988 PyObject *resultobj;
8989 char *kwnames[] = {
8990 NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8994 {
8995 PyThreadState* __tstate = wxPyBeginAllowThreads();
8996 wxFileSystem::CleanUpHandlers();
8997
8998 wxPyEndAllowThreads(__tstate);
8999 if (PyErr_Occurred()) SWIG_fail;
9000 }
9001 Py_INCREF(Py_None); resultobj = Py_None;
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
9008 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj;
9010 wxString *arg1 = 0 ;
9011 wxString result;
9012 bool temp1 = false ;
9013 PyObject * obj0 = 0 ;
9014 char *kwnames[] = {
9015 (char *) "filename", NULL
9016 };
9017
9018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9019 {
9020 arg1 = wxString_in_helper(obj0);
9021 if (arg1 == NULL) SWIG_fail;
9022 temp1 = true;
9023 }
9024 {
9025 PyThreadState* __tstate = wxPyBeginAllowThreads();
9026 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9027
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 {
9032 #if wxUSE_UNICODE
9033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9034 #else
9035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9036 #endif
9037 }
9038 {
9039 if (temp1)
9040 delete arg1;
9041 }
9042 return resultobj;
9043 fail:
9044 {
9045 if (temp1)
9046 delete arg1;
9047 }
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxString *arg1 = 0 ;
9055 wxString result;
9056 bool temp1 = false ;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "url", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9063 {
9064 arg1 = wxString_in_helper(obj0);
9065 if (arg1 == NULL) SWIG_fail;
9066 temp1 = true;
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = FileSystem_URLToFileName((wxString const &)*arg1);
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 {
9076 #if wxUSE_UNICODE
9077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9078 #else
9079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9080 #endif
9081 }
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return resultobj;
9087 fail:
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return NULL;
9093 }
9094
9095
9096 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9097 PyObject *obj;
9098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9099 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9100 Py_INCREF(obj);
9101 return Py_BuildValue((char *)"");
9102 }
9103 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9104 PyObject *resultobj;
9105 wxInternetFSHandler *result;
9106 char *kwnames[] = {
9107 NULL
9108 };
9109
9110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9114
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj;
9127 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9128 wxString *arg2 = 0 ;
9129 bool result;
9130 bool temp2 = false ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "self",(char *) "location", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9139 if (SWIG_arg_fail(1)) SWIG_fail;
9140 {
9141 arg2 = wxString_in_helper(obj1);
9142 if (arg2 == NULL) SWIG_fail;
9143 temp2 = true;
9144 }
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 {
9153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9154 }
9155 {
9156 if (temp2)
9157 delete arg2;
9158 }
9159 return resultobj;
9160 fail:
9161 {
9162 if (temp2)
9163 delete arg2;
9164 }
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj;
9171 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9172 wxFileSystem *arg2 = 0 ;
9173 wxString *arg3 = 0 ;
9174 wxFSFile *result;
9175 bool temp3 = false ;
9176 PyObject * obj0 = 0 ;
9177 PyObject * obj1 = 0 ;
9178 PyObject * obj2 = 0 ;
9179 char *kwnames[] = {
9180 (char *) "self",(char *) "fs",(char *) "location", NULL
9181 };
9182
9183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9185 if (SWIG_arg_fail(1)) SWIG_fail;
9186 {
9187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9188 if (SWIG_arg_fail(2)) SWIG_fail;
9189 if (arg2 == NULL) {
9190 SWIG_null_ref("wxFileSystem");
9191 }
9192 if (SWIG_arg_fail(2)) SWIG_fail;
9193 }
9194 {
9195 arg3 = wxString_in_helper(obj2);
9196 if (arg3 == NULL) SWIG_fail;
9197 temp3 = true;
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = wxPyMake_wxObject(result, 1);
9208 }
9209 {
9210 if (temp3)
9211 delete arg3;
9212 }
9213 return resultobj;
9214 fail:
9215 {
9216 if (temp3)
9217 delete arg3;
9218 }
9219 return NULL;
9220 }
9221
9222
9223 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9224 PyObject *obj;
9225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9226 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9227 Py_INCREF(obj);
9228 return Py_BuildValue((char *)"");
9229 }
9230 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9231 PyObject *resultobj;
9232 wxZipFSHandler *result;
9233 char *kwnames[] = {
9234 NULL
9235 };
9236
9237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9238 {
9239 PyThreadState* __tstate = wxPyBeginAllowThreads();
9240 result = (wxZipFSHandler *)new wxZipFSHandler();
9241
9242 wxPyEndAllowThreads(__tstate);
9243 if (PyErr_Occurred()) SWIG_fail;
9244 }
9245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9246 return resultobj;
9247 fail:
9248 return NULL;
9249 }
9250
9251
9252 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9253 PyObject *resultobj;
9254 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9255 wxString *arg2 = 0 ;
9256 bool result;
9257 bool temp2 = false ;
9258 PyObject * obj0 = 0 ;
9259 PyObject * obj1 = 0 ;
9260 char *kwnames[] = {
9261 (char *) "self",(char *) "location", NULL
9262 };
9263
9264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9266 if (SWIG_arg_fail(1)) SWIG_fail;
9267 {
9268 arg2 = wxString_in_helper(obj1);
9269 if (arg2 == NULL) SWIG_fail;
9270 temp2 = true;
9271 }
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9275
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 {
9280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9281 }
9282 {
9283 if (temp2)
9284 delete arg2;
9285 }
9286 return resultobj;
9287 fail:
9288 {
9289 if (temp2)
9290 delete arg2;
9291 }
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9299 wxFileSystem *arg2 = 0 ;
9300 wxString *arg3 = 0 ;
9301 wxFSFile *result;
9302 bool temp3 = false ;
9303 PyObject * obj0 = 0 ;
9304 PyObject * obj1 = 0 ;
9305 PyObject * obj2 = 0 ;
9306 char *kwnames[] = {
9307 (char *) "self",(char *) "fs",(char *) "location", NULL
9308 };
9309
9310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9312 if (SWIG_arg_fail(1)) SWIG_fail;
9313 {
9314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9315 if (SWIG_arg_fail(2)) SWIG_fail;
9316 if (arg2 == NULL) {
9317 SWIG_null_ref("wxFileSystem");
9318 }
9319 if (SWIG_arg_fail(2)) SWIG_fail;
9320 }
9321 {
9322 arg3 = wxString_in_helper(obj2);
9323 if (arg3 == NULL) SWIG_fail;
9324 temp3 = true;
9325 }
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9329
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 {
9334 resultobj = wxPyMake_wxObject(result, 1);
9335 }
9336 {
9337 if (temp3)
9338 delete arg3;
9339 }
9340 return resultobj;
9341 fail:
9342 {
9343 if (temp3)
9344 delete arg3;
9345 }
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9353 wxString *arg2 = 0 ;
9354 int arg3 = (int) 0 ;
9355 wxString result;
9356 bool temp2 = false ;
9357 PyObject * obj0 = 0 ;
9358 PyObject * obj1 = 0 ;
9359 PyObject * obj2 = 0 ;
9360 char *kwnames[] = {
9361 (char *) "self",(char *) "spec",(char *) "flags", NULL
9362 };
9363
9364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9366 if (SWIG_arg_fail(1)) SWIG_fail;
9367 {
9368 arg2 = wxString_in_helper(obj1);
9369 if (arg2 == NULL) SWIG_fail;
9370 temp2 = true;
9371 }
9372 if (obj2) {
9373 {
9374 arg3 = (int)(SWIG_As_int(obj2));
9375 if (SWIG_arg_fail(3)) SWIG_fail;
9376 }
9377 }
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9381
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 {
9386 #if wxUSE_UNICODE
9387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9388 #else
9389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9390 #endif
9391 }
9392 {
9393 if (temp2)
9394 delete arg2;
9395 }
9396 return resultobj;
9397 fail:
9398 {
9399 if (temp2)
9400 delete arg2;
9401 }
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9409 wxString result;
9410 PyObject * obj0 = 0 ;
9411 char *kwnames[] = {
9412 (char *) "self", NULL
9413 };
9414
9415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9417 if (SWIG_arg_fail(1)) SWIG_fail;
9418 {
9419 PyThreadState* __tstate = wxPyBeginAllowThreads();
9420 result = (arg1)->FindNext();
9421
9422 wxPyEndAllowThreads(__tstate);
9423 if (PyErr_Occurred()) SWIG_fail;
9424 }
9425 {
9426 #if wxUSE_UNICODE
9427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9428 #else
9429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9430 #endif
9431 }
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
9438 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9439 PyObject *obj;
9440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9441 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9442 Py_INCREF(obj);
9443 return Py_BuildValue((char *)"");
9444 }
9445 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj;
9447 wxString *arg1 = 0 ;
9448 wxImage *arg2 = 0 ;
9449 long arg3 ;
9450 bool temp1 = false ;
9451 PyObject * obj0 = 0 ;
9452 PyObject * obj1 = 0 ;
9453 PyObject * obj2 = 0 ;
9454 char *kwnames[] = {
9455 (char *) "filename",(char *) "image",(char *) "type", NULL
9456 };
9457
9458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9459 {
9460 arg1 = wxString_in_helper(obj0);
9461 if (arg1 == NULL) SWIG_fail;
9462 temp1 = true;
9463 }
9464 {
9465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(2)) SWIG_fail;
9467 if (arg2 == NULL) {
9468 SWIG_null_ref("wxImage");
9469 }
9470 if (SWIG_arg_fail(2)) SWIG_fail;
9471 }
9472 {
9473 arg3 = (long)(SWIG_As_long(obj2));
9474 if (SWIG_arg_fail(3)) SWIG_fail;
9475 }
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9479
9480 wxPyEndAllowThreads(__tstate);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 Py_INCREF(Py_None); resultobj = Py_None;
9484 {
9485 if (temp1)
9486 delete arg1;
9487 }
9488 return resultobj;
9489 fail:
9490 {
9491 if (temp1)
9492 delete arg1;
9493 }
9494 return NULL;
9495 }
9496
9497
9498 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9499 PyObject *resultobj;
9500 wxString *arg1 = 0 ;
9501 wxBitmap *arg2 = 0 ;
9502 long arg3 ;
9503 bool temp1 = false ;
9504 PyObject * obj0 = 0 ;
9505 PyObject * obj1 = 0 ;
9506 PyObject * obj2 = 0 ;
9507 char *kwnames[] = {
9508 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9509 };
9510
9511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9512 {
9513 arg1 = wxString_in_helper(obj0);
9514 if (arg1 == NULL) SWIG_fail;
9515 temp1 = true;
9516 }
9517 {
9518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9519 if (SWIG_arg_fail(2)) SWIG_fail;
9520 if (arg2 == NULL) {
9521 SWIG_null_ref("wxBitmap");
9522 }
9523 if (SWIG_arg_fail(2)) SWIG_fail;
9524 }
9525 {
9526 arg3 = (long)(SWIG_As_long(obj2));
9527 if (SWIG_arg_fail(3)) SWIG_fail;
9528 }
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9532
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 Py_INCREF(Py_None); resultobj = Py_None;
9537 {
9538 if (temp1)
9539 delete arg1;
9540 }
9541 return resultobj;
9542 fail:
9543 {
9544 if (temp1)
9545 delete arg1;
9546 }
9547 return NULL;
9548 }
9549
9550
9551 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9552 PyObject *resultobj;
9553 wxString *arg1 = 0 ;
9554 PyObject *arg2 = (PyObject *) 0 ;
9555 bool temp1 = false ;
9556 PyObject * obj0 = 0 ;
9557 PyObject * obj1 = 0 ;
9558 char *kwnames[] = {
9559 (char *) "filename",(char *) "data", NULL
9560 };
9561
9562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9563 {
9564 arg1 = wxString_in_helper(obj0);
9565 if (arg1 == NULL) SWIG_fail;
9566 temp1 = true;
9567 }
9568 arg2 = obj1;
9569 {
9570 PyThreadState* __tstate = wxPyBeginAllowThreads();
9571 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9572
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 Py_INCREF(Py_None); resultobj = Py_None;
9577 {
9578 if (temp1)
9579 delete arg1;
9580 }
9581 return resultobj;
9582 fail:
9583 {
9584 if (temp1)
9585 delete arg1;
9586 }
9587 return NULL;
9588 }
9589
9590
9591 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9592 PyObject *resultobj;
9593 wxMemoryFSHandler *result;
9594 char *kwnames[] = {
9595 NULL
9596 };
9597
9598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9602
9603 wxPyEndAllowThreads(__tstate);
9604 if (PyErr_Occurred()) SWIG_fail;
9605 }
9606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9607 return resultobj;
9608 fail:
9609 return NULL;
9610 }
9611
9612
9613 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9614 PyObject *resultobj;
9615 wxString *arg1 = 0 ;
9616 bool temp1 = false ;
9617 PyObject * obj0 = 0 ;
9618 char *kwnames[] = {
9619 (char *) "filename", NULL
9620 };
9621
9622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9623 {
9624 arg1 = wxString_in_helper(obj0);
9625 if (arg1 == NULL) SWIG_fail;
9626 temp1 = true;
9627 }
9628 {
9629 PyThreadState* __tstate = wxPyBeginAllowThreads();
9630 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9631
9632 wxPyEndAllowThreads(__tstate);
9633 if (PyErr_Occurred()) SWIG_fail;
9634 }
9635 Py_INCREF(Py_None); resultobj = Py_None;
9636 {
9637 if (temp1)
9638 delete arg1;
9639 }
9640 return resultobj;
9641 fail:
9642 {
9643 if (temp1)
9644 delete arg1;
9645 }
9646 return NULL;
9647 }
9648
9649
9650 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9651 PyObject *resultobj;
9652 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9653 wxString *arg2 = 0 ;
9654 bool result;
9655 bool temp2 = false ;
9656 PyObject * obj0 = 0 ;
9657 PyObject * obj1 = 0 ;
9658 char *kwnames[] = {
9659 (char *) "self",(char *) "location", NULL
9660 };
9661
9662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9664 if (SWIG_arg_fail(1)) SWIG_fail;
9665 {
9666 arg2 = wxString_in_helper(obj1);
9667 if (arg2 == NULL) SWIG_fail;
9668 temp2 = true;
9669 }
9670 {
9671 PyThreadState* __tstate = wxPyBeginAllowThreads();
9672 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9673
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 {
9678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9679 }
9680 {
9681 if (temp2)
9682 delete arg2;
9683 }
9684 return resultobj;
9685 fail:
9686 {
9687 if (temp2)
9688 delete arg2;
9689 }
9690 return NULL;
9691 }
9692
9693
9694 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj;
9696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9697 wxFileSystem *arg2 = 0 ;
9698 wxString *arg3 = 0 ;
9699 wxFSFile *result;
9700 bool temp3 = false ;
9701 PyObject * obj0 = 0 ;
9702 PyObject * obj1 = 0 ;
9703 PyObject * obj2 = 0 ;
9704 char *kwnames[] = {
9705 (char *) "self",(char *) "fs",(char *) "location", NULL
9706 };
9707
9708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9710 if (SWIG_arg_fail(1)) SWIG_fail;
9711 {
9712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9713 if (SWIG_arg_fail(2)) SWIG_fail;
9714 if (arg2 == NULL) {
9715 SWIG_null_ref("wxFileSystem");
9716 }
9717 if (SWIG_arg_fail(2)) SWIG_fail;
9718 }
9719 {
9720 arg3 = wxString_in_helper(obj2);
9721 if (arg3 == NULL) SWIG_fail;
9722 temp3 = true;
9723 }
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = wxPyMake_wxObject(result, 1);
9733 }
9734 {
9735 if (temp3)
9736 delete arg3;
9737 }
9738 return resultobj;
9739 fail:
9740 {
9741 if (temp3)
9742 delete arg3;
9743 }
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9751 wxString *arg2 = 0 ;
9752 int arg3 = (int) 0 ;
9753 wxString result;
9754 bool temp2 = false ;
9755 PyObject * obj0 = 0 ;
9756 PyObject * obj1 = 0 ;
9757 PyObject * obj2 = 0 ;
9758 char *kwnames[] = {
9759 (char *) "self",(char *) "spec",(char *) "flags", NULL
9760 };
9761
9762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9764 if (SWIG_arg_fail(1)) SWIG_fail;
9765 {
9766 arg2 = wxString_in_helper(obj1);
9767 if (arg2 == NULL) SWIG_fail;
9768 temp2 = true;
9769 }
9770 if (obj2) {
9771 {
9772 arg3 = (int)(SWIG_As_int(obj2));
9773 if (SWIG_arg_fail(3)) SWIG_fail;
9774 }
9775 }
9776 {
9777 PyThreadState* __tstate = wxPyBeginAllowThreads();
9778 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9779
9780 wxPyEndAllowThreads(__tstate);
9781 if (PyErr_Occurred()) SWIG_fail;
9782 }
9783 {
9784 #if wxUSE_UNICODE
9785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9786 #else
9787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9788 #endif
9789 }
9790 {
9791 if (temp2)
9792 delete arg2;
9793 }
9794 return resultobj;
9795 fail:
9796 {
9797 if (temp2)
9798 delete arg2;
9799 }
9800 return NULL;
9801 }
9802
9803
9804 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9805 PyObject *resultobj;
9806 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9807 wxString result;
9808 PyObject * obj0 = 0 ;
9809 char *kwnames[] = {
9810 (char *) "self", NULL
9811 };
9812
9813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(1)) SWIG_fail;
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 result = (arg1)->FindNext();
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 {
9824 #if wxUSE_UNICODE
9825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9826 #else
9827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9828 #endif
9829 }
9830 return resultobj;
9831 fail:
9832 return NULL;
9833 }
9834
9835
9836 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9837 PyObject *obj;
9838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9839 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9840 Py_INCREF(obj);
9841 return Py_BuildValue((char *)"");
9842 }
9843 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9846 wxString result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (arg1)->GetName();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 {
9863 #if wxUSE_UNICODE
9864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9865 #else
9866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9867 #endif
9868 }
9869 return resultobj;
9870 fail:
9871 return NULL;
9872 }
9873
9874
9875 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9876 PyObject *resultobj;
9877 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9878 wxString result;
9879 PyObject * obj0 = 0 ;
9880 char *kwnames[] = {
9881 (char *) "self", NULL
9882 };
9883
9884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9886 if (SWIG_arg_fail(1)) SWIG_fail;
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = (arg1)->GetExtension();
9890
9891 wxPyEndAllowThreads(__tstate);
9892 if (PyErr_Occurred()) SWIG_fail;
9893 }
9894 {
9895 #if wxUSE_UNICODE
9896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9897 #else
9898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9899 #endif
9900 }
9901 return resultobj;
9902 fail:
9903 return NULL;
9904 }
9905
9906
9907 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9908 PyObject *resultobj;
9909 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9910 long result;
9911 PyObject * obj0 = 0 ;
9912 char *kwnames[] = {
9913 (char *) "self", NULL
9914 };
9915
9916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9918 if (SWIG_arg_fail(1)) SWIG_fail;
9919 {
9920 PyThreadState* __tstate = wxPyBeginAllowThreads();
9921 result = (long)(arg1)->GetType();
9922
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 {
9927 resultobj = SWIG_From_long((long)(result));
9928 }
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj;
9937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9938 wxString result;
9939 PyObject * obj0 = 0 ;
9940 char *kwnames[] = {
9941 (char *) "self", NULL
9942 };
9943
9944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9946 if (SWIG_arg_fail(1)) SWIG_fail;
9947 {
9948 PyThreadState* __tstate = wxPyBeginAllowThreads();
9949 result = (arg1)->GetMimeType();
9950
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 {
9955 #if wxUSE_UNICODE
9956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9957 #else
9958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9959 #endif
9960 }
9961 return resultobj;
9962 fail:
9963 return NULL;
9964 }
9965
9966
9967 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9968 PyObject *resultobj;
9969 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9970 wxString *arg2 = 0 ;
9971 bool result;
9972 bool temp2 = false ;
9973 PyObject * obj0 = 0 ;
9974 PyObject * obj1 = 0 ;
9975 char *kwnames[] = {
9976 (char *) "self",(char *) "name", NULL
9977 };
9978
9979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9981 if (SWIG_arg_fail(1)) SWIG_fail;
9982 {
9983 arg2 = wxString_in_helper(obj1);
9984 if (arg2 == NULL) SWIG_fail;
9985 temp2 = true;
9986 }
9987 {
9988 PyThreadState* __tstate = wxPyBeginAllowThreads();
9989 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9990
9991 wxPyEndAllowThreads(__tstate);
9992 if (PyErr_Occurred()) SWIG_fail;
9993 }
9994 {
9995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9996 }
9997 {
9998 if (temp2)
9999 delete arg2;
10000 }
10001 return resultobj;
10002 fail:
10003 {
10004 if (temp2)
10005 delete arg2;
10006 }
10007 return NULL;
10008 }
10009
10010
10011 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10014 wxString *arg2 = 0 ;
10015 bool temp2 = false ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char *kwnames[] = {
10019 (char *) "self",(char *) "name", NULL
10020 };
10021
10022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10024 if (SWIG_arg_fail(1)) SWIG_fail;
10025 {
10026 arg2 = wxString_in_helper(obj1);
10027 if (arg2 == NULL) SWIG_fail;
10028 temp2 = true;
10029 }
10030 {
10031 PyThreadState* __tstate = wxPyBeginAllowThreads();
10032 (arg1)->SetName((wxString const &)*arg2);
10033
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 Py_INCREF(Py_None); resultobj = Py_None;
10038 {
10039 if (temp2)
10040 delete arg2;
10041 }
10042 return resultobj;
10043 fail:
10044 {
10045 if (temp2)
10046 delete arg2;
10047 }
10048 return NULL;
10049 }
10050
10051
10052 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10053 PyObject *resultobj;
10054 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10055 wxString *arg2 = 0 ;
10056 bool temp2 = false ;
10057 PyObject * obj0 = 0 ;
10058 PyObject * obj1 = 0 ;
10059 char *kwnames[] = {
10060 (char *) "self",(char *) "extension", NULL
10061 };
10062
10063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10065 if (SWIG_arg_fail(1)) SWIG_fail;
10066 {
10067 arg2 = wxString_in_helper(obj1);
10068 if (arg2 == NULL) SWIG_fail;
10069 temp2 = true;
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 (arg1)->SetExtension((wxString const &)*arg2);
10074
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 Py_INCREF(Py_None); resultobj = Py_None;
10079 {
10080 if (temp2)
10081 delete arg2;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp2)
10087 delete arg2;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj;
10095 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10096 long arg2 ;
10097 PyObject * obj0 = 0 ;
10098 PyObject * obj1 = 0 ;
10099 char *kwnames[] = {
10100 (char *) "self",(char *) "type", NULL
10101 };
10102
10103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10105 if (SWIG_arg_fail(1)) SWIG_fail;
10106 {
10107 arg2 = (long)(SWIG_As_long(obj1));
10108 if (SWIG_arg_fail(2)) SWIG_fail;
10109 }
10110 {
10111 PyThreadState* __tstate = wxPyBeginAllowThreads();
10112 (arg1)->SetType(arg2);
10113
10114 wxPyEndAllowThreads(__tstate);
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 Py_INCREF(Py_None); resultobj = Py_None;
10118 return resultobj;
10119 fail:
10120 return NULL;
10121 }
10122
10123
10124 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj;
10126 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10127 wxString *arg2 = 0 ;
10128 bool temp2 = false ;
10129 PyObject * obj0 = 0 ;
10130 PyObject * obj1 = 0 ;
10131 char *kwnames[] = {
10132 (char *) "self",(char *) "mimetype", NULL
10133 };
10134
10135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10137 if (SWIG_arg_fail(1)) SWIG_fail;
10138 {
10139 arg2 = wxString_in_helper(obj1);
10140 if (arg2 == NULL) SWIG_fail;
10141 temp2 = true;
10142 }
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 (arg1)->SetMimeType((wxString const &)*arg2);
10146
10147 wxPyEndAllowThreads(__tstate);
10148 if (PyErr_Occurred()) SWIG_fail;
10149 }
10150 Py_INCREF(Py_None); resultobj = Py_None;
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return resultobj;
10156 fail:
10157 {
10158 if (temp2)
10159 delete arg2;
10160 }
10161 return NULL;
10162 }
10163
10164
10165 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10166 PyObject *obj;
10167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10168 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10169 Py_INCREF(obj);
10170 return Py_BuildValue((char *)"");
10171 }
10172 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10173 PyObject *resultobj;
10174 wxImageHistogram *result;
10175 char *kwnames[] = {
10176 NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 result = (wxImageHistogram *)new wxImageHistogram();
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj;
10196 unsigned char arg1 ;
10197 unsigned char arg2 ;
10198 unsigned char arg3 ;
10199 unsigned long result;
10200 PyObject * obj0 = 0 ;
10201 PyObject * obj1 = 0 ;
10202 PyObject * obj2 = 0 ;
10203 char *kwnames[] = {
10204 (char *) "r",(char *) "g",(char *) "b", NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10208 {
10209 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10210 if (SWIG_arg_fail(1)) SWIG_fail;
10211 }
10212 {
10213 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10214 if (SWIG_arg_fail(2)) SWIG_fail;
10215 }
10216 {
10217 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10218 if (SWIG_arg_fail(3)) SWIG_fail;
10219 }
10220 {
10221 PyThreadState* __tstate = wxPyBeginAllowThreads();
10222 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10223
10224 wxPyEndAllowThreads(__tstate);
10225 if (PyErr_Occurred()) SWIG_fail;
10226 }
10227 {
10228 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10229 }
10230 return resultobj;
10231 fail:
10232 return NULL;
10233 }
10234
10235
10236 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10237 PyObject *resultobj;
10238 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10239 unsigned char *arg2 = (unsigned char *) 0 ;
10240 unsigned char *arg3 = (unsigned char *) 0 ;
10241 unsigned char *arg4 = (unsigned char *) 0 ;
10242 unsigned char arg5 = (unsigned char) 1 ;
10243 unsigned char arg6 = (unsigned char) 0 ;
10244 unsigned char arg7 = (unsigned char) 0 ;
10245 bool result;
10246 unsigned char temp2 ;
10247 int res2 = 0 ;
10248 unsigned char temp3 ;
10249 int res3 = 0 ;
10250 unsigned char temp4 ;
10251 int res4 = 0 ;
10252 PyObject * obj0 = 0 ;
10253 PyObject * obj1 = 0 ;
10254 PyObject * obj2 = 0 ;
10255 PyObject * obj3 = 0 ;
10256 char *kwnames[] = {
10257 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10258 };
10259
10260 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10261 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10262 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10265 if (SWIG_arg_fail(1)) SWIG_fail;
10266 if (obj1) {
10267 {
10268 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10269 if (SWIG_arg_fail(5)) SWIG_fail;
10270 }
10271 }
10272 if (obj2) {
10273 {
10274 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10275 if (SWIG_arg_fail(6)) SWIG_fail;
10276 }
10277 }
10278 if (obj3) {
10279 {
10280 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10281 if (SWIG_arg_fail(7)) SWIG_fail;
10282 }
10283 }
10284 {
10285 PyThreadState* __tstate = wxPyBeginAllowThreads();
10286 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10287
10288 wxPyEndAllowThreads(__tstate);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 {
10292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10293 }
10294 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10295 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10296 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10297 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10298 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10299 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10307 PyObject *obj;
10308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10309 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10310 Py_INCREF(obj);
10311 return Py_BuildValue((char *)"");
10312 }
10313 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj;
10315 wxString *arg1 = 0 ;
10316 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10317 int arg3 = (int) -1 ;
10318 wxImage *result;
10319 bool temp1 = false ;
10320 PyObject * obj0 = 0 ;
10321 PyObject * obj1 = 0 ;
10322 PyObject * obj2 = 0 ;
10323 char *kwnames[] = {
10324 (char *) "name",(char *) "type",(char *) "index", NULL
10325 };
10326
10327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10328 {
10329 arg1 = wxString_in_helper(obj0);
10330 if (arg1 == NULL) SWIG_fail;
10331 temp1 = true;
10332 }
10333 if (obj1) {
10334 {
10335 arg2 = (long)(SWIG_As_long(obj1));
10336 if (SWIG_arg_fail(2)) SWIG_fail;
10337 }
10338 }
10339 if (obj2) {
10340 {
10341 arg3 = (int)(SWIG_As_int(obj2));
10342 if (SWIG_arg_fail(3)) SWIG_fail;
10343 }
10344 }
10345 {
10346 PyThreadState* __tstate = wxPyBeginAllowThreads();
10347 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10348
10349 wxPyEndAllowThreads(__tstate);
10350 if (PyErr_Occurred()) SWIG_fail;
10351 }
10352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10353 {
10354 if (temp1)
10355 delete arg1;
10356 }
10357 return resultobj;
10358 fail:
10359 {
10360 if (temp1)
10361 delete arg1;
10362 }
10363 return NULL;
10364 }
10365
10366
10367 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj;
10369 wxImage *arg1 = (wxImage *) 0 ;
10370 PyObject * obj0 = 0 ;
10371 char *kwnames[] = {
10372 (char *) "self", NULL
10373 };
10374
10375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10377 if (SWIG_arg_fail(1)) SWIG_fail;
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 delete arg1;
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 Py_INCREF(Py_None); resultobj = Py_None;
10386 return resultobj;
10387 fail:
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj;
10394 wxString *arg1 = 0 ;
10395 wxString *arg2 = 0 ;
10396 int arg3 = (int) -1 ;
10397 wxImage *result;
10398 bool temp1 = false ;
10399 bool temp2 = false ;
10400 PyObject * obj0 = 0 ;
10401 PyObject * obj1 = 0 ;
10402 PyObject * obj2 = 0 ;
10403 char *kwnames[] = {
10404 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10405 };
10406
10407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10408 {
10409 arg1 = wxString_in_helper(obj0);
10410 if (arg1 == NULL) SWIG_fail;
10411 temp1 = true;
10412 }
10413 {
10414 arg2 = wxString_in_helper(obj1);
10415 if (arg2 == NULL) SWIG_fail;
10416 temp2 = true;
10417 }
10418 if (obj2) {
10419 {
10420 arg3 = (int)(SWIG_As_int(obj2));
10421 if (SWIG_arg_fail(3)) SWIG_fail;
10422 }
10423 }
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10432 {
10433 if (temp1)
10434 delete arg1;
10435 }
10436 {
10437 if (temp2)
10438 delete arg2;
10439 }
10440 return resultobj;
10441 fail:
10442 {
10443 if (temp1)
10444 delete arg1;
10445 }
10446 {
10447 if (temp2)
10448 delete arg2;
10449 }
10450 return NULL;
10451 }
10452
10453
10454 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10455 PyObject *resultobj;
10456 wxInputStream *arg1 = 0 ;
10457 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10458 int arg3 = (int) -1 ;
10459 wxImage *result;
10460 wxPyInputStream *temp1 ;
10461 bool created1 ;
10462 PyObject * obj0 = 0 ;
10463 PyObject * obj1 = 0 ;
10464 PyObject * obj2 = 0 ;
10465 char *kwnames[] = {
10466 (char *) "stream",(char *) "type",(char *) "index", NULL
10467 };
10468
10469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10470 {
10471 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10472 arg1 = temp1->m_wxis;
10473 created1 = false;
10474 } else {
10475 PyErr_Clear(); // clear the failure of the wxPyConvert above
10476 arg1 = wxPyCBInputStream_create(obj0, false);
10477 if (arg1 == NULL) {
10478 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10479 SWIG_fail;
10480 }
10481 created1 = true;
10482 }
10483 }
10484 if (obj1) {
10485 {
10486 arg2 = (long)(SWIG_As_long(obj1));
10487 if (SWIG_arg_fail(2)) SWIG_fail;
10488 }
10489 }
10490 if (obj2) {
10491 {
10492 arg3 = (int)(SWIG_As_int(obj2));
10493 if (SWIG_arg_fail(3)) SWIG_fail;
10494 }
10495 }
10496 {
10497 PyThreadState* __tstate = wxPyBeginAllowThreads();
10498 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10499
10500 wxPyEndAllowThreads(__tstate);
10501 if (PyErr_Occurred()) SWIG_fail;
10502 }
10503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10504 {
10505 if (created1) delete arg1;
10506 }
10507 return resultobj;
10508 fail:
10509 {
10510 if (created1) delete arg1;
10511 }
10512 return NULL;
10513 }
10514
10515
10516 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj;
10518 wxInputStream *arg1 = 0 ;
10519 wxString *arg2 = 0 ;
10520 int arg3 = (int) -1 ;
10521 wxImage *result;
10522 wxPyInputStream *temp1 ;
10523 bool created1 ;
10524 bool temp2 = false ;
10525 PyObject * obj0 = 0 ;
10526 PyObject * obj1 = 0 ;
10527 PyObject * obj2 = 0 ;
10528 char *kwnames[] = {
10529 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10530 };
10531
10532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10533 {
10534 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10535 arg1 = temp1->m_wxis;
10536 created1 = false;
10537 } else {
10538 PyErr_Clear(); // clear the failure of the wxPyConvert above
10539 arg1 = wxPyCBInputStream_create(obj0, false);
10540 if (arg1 == NULL) {
10541 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10542 SWIG_fail;
10543 }
10544 created1 = true;
10545 }
10546 }
10547 {
10548 arg2 = wxString_in_helper(obj1);
10549 if (arg2 == NULL) SWIG_fail;
10550 temp2 = true;
10551 }
10552 if (obj2) {
10553 {
10554 arg3 = (int)(SWIG_As_int(obj2));
10555 if (SWIG_arg_fail(3)) SWIG_fail;
10556 }
10557 }
10558 {
10559 PyThreadState* __tstate = wxPyBeginAllowThreads();
10560 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10561
10562 wxPyEndAllowThreads(__tstate);
10563 if (PyErr_Occurred()) SWIG_fail;
10564 }
10565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10566 {
10567 if (created1) delete arg1;
10568 }
10569 {
10570 if (temp2)
10571 delete arg2;
10572 }
10573 return resultobj;
10574 fail:
10575 {
10576 if (created1) delete arg1;
10577 }
10578 {
10579 if (temp2)
10580 delete arg2;
10581 }
10582 return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj;
10588 int arg1 = (int) 0 ;
10589 int arg2 = (int) 0 ;
10590 bool arg3 = (bool) true ;
10591 wxImage *result;
10592 PyObject * obj0 = 0 ;
10593 PyObject * obj1 = 0 ;
10594 PyObject * obj2 = 0 ;
10595 char *kwnames[] = {
10596 (char *) "width",(char *) "height",(char *) "clear", NULL
10597 };
10598
10599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10600 if (obj0) {
10601 {
10602 arg1 = (int)(SWIG_As_int(obj0));
10603 if (SWIG_arg_fail(1)) SWIG_fail;
10604 }
10605 }
10606 if (obj1) {
10607 {
10608 arg2 = (int)(SWIG_As_int(obj1));
10609 if (SWIG_arg_fail(2)) SWIG_fail;
10610 }
10611 }
10612 if (obj2) {
10613 {
10614 arg3 = (bool)(SWIG_As_bool(obj2));
10615 if (SWIG_arg_fail(3)) SWIG_fail;
10616 }
10617 }
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10621
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj;
10634 wxBitmap *arg1 = 0 ;
10635 wxImage *result;
10636 PyObject * obj0 = 0 ;
10637 char *kwnames[] = {
10638 (char *) "bitmap", NULL
10639 };
10640
10641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10642 {
10643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10644 if (SWIG_arg_fail(1)) SWIG_fail;
10645 if (arg1 == NULL) {
10646 SWIG_null_ref("wxBitmap");
10647 }
10648 if (SWIG_arg_fail(1)) SWIG_fail;
10649 }
10650 {
10651 if (!wxPyCheckForApp()) SWIG_fail;
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10654
10655 wxPyEndAllowThreads(__tstate);
10656 if (PyErr_Occurred()) SWIG_fail;
10657 }
10658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10659 return resultobj;
10660 fail:
10661 return NULL;
10662 }
10663
10664
10665 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10666 PyObject *resultobj;
10667 int arg1 ;
10668 int arg2 ;
10669 unsigned char *arg3 = (unsigned char *) 0 ;
10670 wxImage *result;
10671 PyObject * obj0 = 0 ;
10672 PyObject * obj1 = 0 ;
10673 PyObject * obj2 = 0 ;
10674 char *kwnames[] = {
10675 (char *) "width",(char *) "height",(char *) "data", NULL
10676 };
10677
10678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10679 {
10680 arg1 = (int)(SWIG_As_int(obj0));
10681 if (SWIG_arg_fail(1)) SWIG_fail;
10682 }
10683 {
10684 arg2 = (int)(SWIG_As_int(obj1));
10685 if (SWIG_arg_fail(2)) SWIG_fail;
10686 }
10687 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10688 if (SWIG_arg_fail(3)) SWIG_fail;
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10692
10693 wxPyEndAllowThreads(__tstate);
10694 if (PyErr_Occurred()) SWIG_fail;
10695 }
10696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10697 return resultobj;
10698 fail:
10699 return NULL;
10700 }
10701
10702
10703 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10704 PyObject *resultobj;
10705 int arg1 ;
10706 int arg2 ;
10707 unsigned char *arg3 = (unsigned char *) 0 ;
10708 unsigned char *arg4 = (unsigned char *) 0 ;
10709 wxImage *result;
10710 PyObject * obj0 = 0 ;
10711 PyObject * obj1 = 0 ;
10712 PyObject * obj2 = 0 ;
10713 PyObject * obj3 = 0 ;
10714 char *kwnames[] = {
10715 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10716 };
10717
10718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10719 {
10720 arg1 = (int)(SWIG_As_int(obj0));
10721 if (SWIG_arg_fail(1)) SWIG_fail;
10722 }
10723 {
10724 arg2 = (int)(SWIG_As_int(obj1));
10725 if (SWIG_arg_fail(2)) SWIG_fail;
10726 }
10727 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10728 if (SWIG_arg_fail(3)) SWIG_fail;
10729 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10730 if (SWIG_arg_fail(4)) SWIG_fail;
10731 {
10732 PyThreadState* __tstate = wxPyBeginAllowThreads();
10733 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10734
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 wxImage *arg1 = (wxImage *) 0 ;
10748 int arg2 ;
10749 int arg3 ;
10750 PyObject * obj0 = 0 ;
10751 PyObject * obj1 = 0 ;
10752 PyObject * obj2 = 0 ;
10753 char *kwnames[] = {
10754 (char *) "self",(char *) "width",(char *) "height", NULL
10755 };
10756
10757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10759 if (SWIG_arg_fail(1)) SWIG_fail;
10760 {
10761 arg2 = (int)(SWIG_As_int(obj1));
10762 if (SWIG_arg_fail(2)) SWIG_fail;
10763 }
10764 {
10765 arg3 = (int)(SWIG_As_int(obj2));
10766 if (SWIG_arg_fail(3)) SWIG_fail;
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 (arg1)->Create(arg2,arg3);
10771
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 Py_INCREF(Py_None); resultobj = Py_None;
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10783 PyObject *resultobj;
10784 wxImage *arg1 = (wxImage *) 0 ;
10785 PyObject * obj0 = 0 ;
10786 char *kwnames[] = {
10787 (char *) "self", NULL
10788 };
10789
10790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10792 if (SWIG_arg_fail(1)) SWIG_fail;
10793 {
10794 PyThreadState* __tstate = wxPyBeginAllowThreads();
10795 (arg1)->Destroy();
10796
10797 wxPyEndAllowThreads(__tstate);
10798 if (PyErr_Occurred()) SWIG_fail;
10799 }
10800 Py_INCREF(Py_None); resultobj = Py_None;
10801 return resultobj;
10802 fail:
10803 return NULL;
10804 }
10805
10806
10807 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10808 PyObject *resultobj;
10809 wxImage *arg1 = (wxImage *) 0 ;
10810 int arg2 ;
10811 int arg3 ;
10812 SwigValueWrapper<wxImage > result;
10813 PyObject * obj0 = 0 ;
10814 PyObject * obj1 = 0 ;
10815 PyObject * obj2 = 0 ;
10816 char *kwnames[] = {
10817 (char *) "self",(char *) "width",(char *) "height", NULL
10818 };
10819
10820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10822 if (SWIG_arg_fail(1)) SWIG_fail;
10823 {
10824 arg2 = (int)(SWIG_As_int(obj1));
10825 if (SWIG_arg_fail(2)) SWIG_fail;
10826 }
10827 {
10828 arg3 = (int)(SWIG_As_int(obj2));
10829 if (SWIG_arg_fail(3)) SWIG_fail;
10830 }
10831 {
10832 PyThreadState* __tstate = wxPyBeginAllowThreads();
10833 result = (arg1)->Scale(arg2,arg3);
10834
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 {
10839 wxImage * resultptr;
10840 resultptr = new wxImage((wxImage &)(result));
10841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10842 }
10843 return resultobj;
10844 fail:
10845 return NULL;
10846 }
10847
10848
10849 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10850 PyObject *resultobj;
10851 wxImage *arg1 = (wxImage *) 0 ;
10852 int arg2 ;
10853 int arg3 ;
10854 SwigValueWrapper<wxImage > result;
10855 PyObject * obj0 = 0 ;
10856 PyObject * obj1 = 0 ;
10857 PyObject * obj2 = 0 ;
10858 char *kwnames[] = {
10859 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10860 };
10861
10862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10864 if (SWIG_arg_fail(1)) SWIG_fail;
10865 {
10866 arg2 = (int)(SWIG_As_int(obj1));
10867 if (SWIG_arg_fail(2)) SWIG_fail;
10868 }
10869 {
10870 arg3 = (int)(SWIG_As_int(obj2));
10871 if (SWIG_arg_fail(3)) SWIG_fail;
10872 }
10873 {
10874 PyThreadState* __tstate = wxPyBeginAllowThreads();
10875 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10876
10877 wxPyEndAllowThreads(__tstate);
10878 if (PyErr_Occurred()) SWIG_fail;
10879 }
10880 {
10881 wxImage * resultptr;
10882 resultptr = new wxImage((wxImage &)(result));
10883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10884 }
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj;
10893 wxImage *arg1 = (wxImage *) 0 ;
10894 int arg2 ;
10895 int arg3 ;
10896 wxImage *result;
10897 PyObject * obj0 = 0 ;
10898 PyObject * obj1 = 0 ;
10899 PyObject * obj2 = 0 ;
10900 char *kwnames[] = {
10901 (char *) "self",(char *) "width",(char *) "height", NULL
10902 };
10903
10904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10906 if (SWIG_arg_fail(1)) SWIG_fail;
10907 {
10908 arg2 = (int)(SWIG_As_int(obj1));
10909 if (SWIG_arg_fail(2)) SWIG_fail;
10910 }
10911 {
10912 arg3 = (int)(SWIG_As_int(obj2));
10913 if (SWIG_arg_fail(3)) SWIG_fail;
10914 }
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 {
10918 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10919 result = (wxImage *) &_result_ref;
10920 }
10921
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj;
10934 wxImage *arg1 = (wxImage *) 0 ;
10935 int arg2 ;
10936 int arg3 ;
10937 unsigned char arg4 ;
10938 unsigned char arg5 ;
10939 unsigned char arg6 ;
10940 PyObject * obj0 = 0 ;
10941 PyObject * obj1 = 0 ;
10942 PyObject * obj2 = 0 ;
10943 PyObject * obj3 = 0 ;
10944 PyObject * obj4 = 0 ;
10945 PyObject * obj5 = 0 ;
10946 char *kwnames[] = {
10947 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10948 };
10949
10950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10952 if (SWIG_arg_fail(1)) SWIG_fail;
10953 {
10954 arg2 = (int)(SWIG_As_int(obj1));
10955 if (SWIG_arg_fail(2)) SWIG_fail;
10956 }
10957 {
10958 arg3 = (int)(SWIG_As_int(obj2));
10959 if (SWIG_arg_fail(3)) SWIG_fail;
10960 }
10961 {
10962 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10963 if (SWIG_arg_fail(4)) SWIG_fail;
10964 }
10965 {
10966 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10967 if (SWIG_arg_fail(5)) SWIG_fail;
10968 }
10969 {
10970 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10971 if (SWIG_arg_fail(6)) SWIG_fail;
10972 }
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10976
10977 wxPyEndAllowThreads(__tstate);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 Py_INCREF(Py_None); resultobj = Py_None;
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10988 PyObject *resultobj;
10989 wxImage *arg1 = (wxImage *) 0 ;
10990 int arg2 ;
10991 int arg3 ;
10992 unsigned char result;
10993 PyObject * obj0 = 0 ;
10994 PyObject * obj1 = 0 ;
10995 PyObject * obj2 = 0 ;
10996 char *kwnames[] = {
10997 (char *) "self",(char *) "x",(char *) "y", NULL
10998 };
10999
11000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11002 if (SWIG_arg_fail(1)) SWIG_fail;
11003 {
11004 arg2 = (int)(SWIG_As_int(obj1));
11005 if (SWIG_arg_fail(2)) SWIG_fail;
11006 }
11007 {
11008 arg3 = (int)(SWIG_As_int(obj2));
11009 if (SWIG_arg_fail(3)) SWIG_fail;
11010 }
11011 {
11012 PyThreadState* __tstate = wxPyBeginAllowThreads();
11013 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11014
11015 wxPyEndAllowThreads(__tstate);
11016 if (PyErr_Occurred()) SWIG_fail;
11017 }
11018 {
11019 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11020 }
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj;
11029 wxImage *arg1 = (wxImage *) 0 ;
11030 int arg2 ;
11031 int arg3 ;
11032 unsigned char result;
11033 PyObject * obj0 = 0 ;
11034 PyObject * obj1 = 0 ;
11035 PyObject * obj2 = 0 ;
11036 char *kwnames[] = {
11037 (char *) "self",(char *) "x",(char *) "y", NULL
11038 };
11039
11040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11042 if (SWIG_arg_fail(1)) SWIG_fail;
11043 {
11044 arg2 = (int)(SWIG_As_int(obj1));
11045 if (SWIG_arg_fail(2)) SWIG_fail;
11046 }
11047 {
11048 arg3 = (int)(SWIG_As_int(obj2));
11049 if (SWIG_arg_fail(3)) SWIG_fail;
11050 }
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11054
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 {
11059 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11060 }
11061 return resultobj;
11062 fail:
11063 return NULL;
11064 }
11065
11066
11067 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11068 PyObject *resultobj;
11069 wxImage *arg1 = (wxImage *) 0 ;
11070 int arg2 ;
11071 int arg3 ;
11072 unsigned char result;
11073 PyObject * obj0 = 0 ;
11074 PyObject * obj1 = 0 ;
11075 PyObject * obj2 = 0 ;
11076 char *kwnames[] = {
11077 (char *) "self",(char *) "x",(char *) "y", NULL
11078 };
11079
11080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11082 if (SWIG_arg_fail(1)) SWIG_fail;
11083 {
11084 arg2 = (int)(SWIG_As_int(obj1));
11085 if (SWIG_arg_fail(2)) SWIG_fail;
11086 }
11087 {
11088 arg3 = (int)(SWIG_As_int(obj2));
11089 if (SWIG_arg_fail(3)) SWIG_fail;
11090 }
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11094
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11100 }
11101 return resultobj;
11102 fail:
11103 return NULL;
11104 }
11105
11106
11107 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11108 PyObject *resultobj;
11109 wxImage *arg1 = (wxImage *) 0 ;
11110 int arg2 ;
11111 int arg3 ;
11112 unsigned char arg4 ;
11113 PyObject * obj0 = 0 ;
11114 PyObject * obj1 = 0 ;
11115 PyObject * obj2 = 0 ;
11116 PyObject * obj3 = 0 ;
11117 char *kwnames[] = {
11118 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11119 };
11120
11121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11123 if (SWIG_arg_fail(1)) SWIG_fail;
11124 {
11125 arg2 = (int)(SWIG_As_int(obj1));
11126 if (SWIG_arg_fail(2)) SWIG_fail;
11127 }
11128 {
11129 arg3 = (int)(SWIG_As_int(obj2));
11130 if (SWIG_arg_fail(3)) SWIG_fail;
11131 }
11132 {
11133 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11134 if (SWIG_arg_fail(4)) SWIG_fail;
11135 }
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 (arg1)->SetAlpha(arg2,arg3,arg4);
11139
11140 wxPyEndAllowThreads(__tstate);
11141 if (PyErr_Occurred()) SWIG_fail;
11142 }
11143 Py_INCREF(Py_None); resultobj = Py_None;
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11151 PyObject *resultobj;
11152 wxImage *arg1 = (wxImage *) 0 ;
11153 int arg2 ;
11154 int arg3 ;
11155 unsigned char result;
11156 PyObject * obj0 = 0 ;
11157 PyObject * obj1 = 0 ;
11158 PyObject * obj2 = 0 ;
11159 char *kwnames[] = {
11160 (char *) "self",(char *) "x",(char *) "y", NULL
11161 };
11162
11163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11165 if (SWIG_arg_fail(1)) SWIG_fail;
11166 {
11167 arg2 = (int)(SWIG_As_int(obj1));
11168 if (SWIG_arg_fail(2)) SWIG_fail;
11169 }
11170 {
11171 arg3 = (int)(SWIG_As_int(obj2));
11172 if (SWIG_arg_fail(3)) SWIG_fail;
11173 }
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11177
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 {
11182 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11183 }
11184 return resultobj;
11185 fail:
11186 return NULL;
11187 }
11188
11189
11190 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj;
11192 wxImage *arg1 = (wxImage *) 0 ;
11193 bool result;
11194 PyObject * obj0 = 0 ;
11195 char *kwnames[] = {
11196 (char *) "self", NULL
11197 };
11198
11199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11201 if (SWIG_arg_fail(1)) SWIG_fail;
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 result = (bool)(arg1)->HasAlpha();
11205
11206 wxPyEndAllowThreads(__tstate);
11207 if (PyErr_Occurred()) SWIG_fail;
11208 }
11209 {
11210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11211 }
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11219 PyObject *resultobj;
11220 wxImage *arg1 = (wxImage *) 0 ;
11221 PyObject * obj0 = 0 ;
11222 char *kwnames[] = {
11223 (char *) "self", NULL
11224 };
11225
11226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11228 if (SWIG_arg_fail(1)) SWIG_fail;
11229 {
11230 PyThreadState* __tstate = wxPyBeginAllowThreads();
11231 (arg1)->InitAlpha();
11232
11233 wxPyEndAllowThreads(__tstate);
11234 if (PyErr_Occurred()) SWIG_fail;
11235 }
11236 Py_INCREF(Py_None); resultobj = Py_None;
11237 return resultobj;
11238 fail:
11239 return NULL;
11240 }
11241
11242
11243 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11244 PyObject *resultobj;
11245 wxImage *arg1 = (wxImage *) 0 ;
11246 byte *arg2 = (byte *) 0 ;
11247 byte *arg3 = (byte *) 0 ;
11248 byte *arg4 = (byte *) 0 ;
11249 byte arg5 = (byte) 0 ;
11250 byte arg6 = (byte) 0 ;
11251 byte arg7 = (byte) 0 ;
11252 bool result;
11253 byte temp2 ;
11254 int res2 = 0 ;
11255 byte temp3 ;
11256 int res3 = 0 ;
11257 byte temp4 ;
11258 int res4 = 0 ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 PyObject * obj3 = 0 ;
11263 char *kwnames[] = {
11264 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11265 };
11266
11267 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11268 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11269 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11272 if (SWIG_arg_fail(1)) SWIG_fail;
11273 if (obj1) {
11274 {
11275 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11276 if (SWIG_arg_fail(5)) SWIG_fail;
11277 }
11278 }
11279 if (obj2) {
11280 {
11281 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11282 if (SWIG_arg_fail(6)) SWIG_fail;
11283 }
11284 }
11285 if (obj3) {
11286 {
11287 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11288 if (SWIG_arg_fail(7)) SWIG_fail;
11289 }
11290 }
11291 {
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11294
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 {
11299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11300 }
11301 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11302 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11303 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11304 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11305 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11306 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11307 return resultobj;
11308 fail:
11309 return NULL;
11310 }
11311
11312
11313 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj;
11315 wxImage *arg1 = (wxImage *) 0 ;
11316 byte arg2 = (byte) 128 ;
11317 bool result;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 char *kwnames[] = {
11321 (char *) "self",(char *) "threshold", NULL
11322 };
11323
11324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11326 if (SWIG_arg_fail(1)) SWIG_fail;
11327 if (obj1) {
11328 {
11329 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11330 if (SWIG_arg_fail(2)) SWIG_fail;
11331 }
11332 }
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11336
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 {
11341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxImage *arg1 = (wxImage *) 0 ;
11352 unsigned char arg2 ;
11353 unsigned char arg3 ;
11354 unsigned char arg4 ;
11355 bool result;
11356 PyObject * obj0 = 0 ;
11357 PyObject * obj1 = 0 ;
11358 PyObject * obj2 = 0 ;
11359 PyObject * obj3 = 0 ;
11360 char *kwnames[] = {
11361 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11362 };
11363
11364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11366 if (SWIG_arg_fail(1)) SWIG_fail;
11367 {
11368 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11369 if (SWIG_arg_fail(2)) SWIG_fail;
11370 }
11371 {
11372 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11373 if (SWIG_arg_fail(3)) SWIG_fail;
11374 }
11375 {
11376 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11377 if (SWIG_arg_fail(4)) SWIG_fail;
11378 }
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11382
11383 wxPyEndAllowThreads(__tstate);
11384 if (PyErr_Occurred()) SWIG_fail;
11385 }
11386 {
11387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11388 }
11389 return resultobj;
11390 fail:
11391 return NULL;
11392 }
11393
11394
11395 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11396 PyObject *resultobj;
11397 wxImage *arg1 = (wxImage *) 0 ;
11398 wxImage *arg2 = 0 ;
11399 byte arg3 ;
11400 byte arg4 ;
11401 byte arg5 ;
11402 bool result;
11403 PyObject * obj0 = 0 ;
11404 PyObject * obj1 = 0 ;
11405 PyObject * obj2 = 0 ;
11406 PyObject * obj3 = 0 ;
11407 PyObject * obj4 = 0 ;
11408 char *kwnames[] = {
11409 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11410 };
11411
11412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11414 if (SWIG_arg_fail(1)) SWIG_fail;
11415 {
11416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11417 if (SWIG_arg_fail(2)) SWIG_fail;
11418 if (arg2 == NULL) {
11419 SWIG_null_ref("wxImage");
11420 }
11421 if (SWIG_arg_fail(2)) SWIG_fail;
11422 }
11423 {
11424 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11425 if (SWIG_arg_fail(3)) SWIG_fail;
11426 }
11427 {
11428 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11429 if (SWIG_arg_fail(4)) SWIG_fail;
11430 }
11431 {
11432 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11433 if (SWIG_arg_fail(5)) SWIG_fail;
11434 }
11435 {
11436 PyThreadState* __tstate = wxPyBeginAllowThreads();
11437 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11438
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 {
11443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11444 }
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj;
11453 wxString *arg1 = 0 ;
11454 bool result;
11455 bool temp1 = false ;
11456 PyObject * obj0 = 0 ;
11457 char *kwnames[] = {
11458 (char *) "name", NULL
11459 };
11460
11461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11462 {
11463 arg1 = wxString_in_helper(obj0);
11464 if (arg1 == NULL) SWIG_fail;
11465 temp1 = true;
11466 }
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11470
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 {
11475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11476 }
11477 {
11478 if (temp1)
11479 delete arg1;
11480 }
11481 return resultobj;
11482 fail:
11483 {
11484 if (temp1)
11485 delete arg1;
11486 }
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj;
11493 wxString *arg1 = 0 ;
11494 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11495 int result;
11496 bool temp1 = false ;
11497 PyObject * obj0 = 0 ;
11498 PyObject * obj1 = 0 ;
11499 char *kwnames[] = {
11500 (char *) "name",(char *) "type", NULL
11501 };
11502
11503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11504 {
11505 arg1 = wxString_in_helper(obj0);
11506 if (arg1 == NULL) SWIG_fail;
11507 temp1 = true;
11508 }
11509 if (obj1) {
11510 {
11511 arg2 = (long)(SWIG_As_long(obj1));
11512 if (SWIG_arg_fail(2)) SWIG_fail;
11513 }
11514 }
11515 {
11516 PyThreadState* __tstate = wxPyBeginAllowThreads();
11517 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11518
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 {
11523 resultobj = SWIG_From_int((int)(result));
11524 }
11525 {
11526 if (temp1)
11527 delete arg1;
11528 }
11529 return resultobj;
11530 fail:
11531 {
11532 if (temp1)
11533 delete arg1;
11534 }
11535 return NULL;
11536 }
11537
11538
11539 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11540 PyObject *resultobj;
11541 wxImage *arg1 = (wxImage *) 0 ;
11542 wxString *arg2 = 0 ;
11543 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11544 int arg4 = (int) -1 ;
11545 bool result;
11546 bool temp2 = false ;
11547 PyObject * obj0 = 0 ;
11548 PyObject * obj1 = 0 ;
11549 PyObject * obj2 = 0 ;
11550 PyObject * obj3 = 0 ;
11551 char *kwnames[] = {
11552 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11553 };
11554
11555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11557 if (SWIG_arg_fail(1)) SWIG_fail;
11558 {
11559 arg2 = wxString_in_helper(obj1);
11560 if (arg2 == NULL) SWIG_fail;
11561 temp2 = true;
11562 }
11563 if (obj2) {
11564 {
11565 arg3 = (long)(SWIG_As_long(obj2));
11566 if (SWIG_arg_fail(3)) SWIG_fail;
11567 }
11568 }
11569 if (obj3) {
11570 {
11571 arg4 = (int)(SWIG_As_int(obj3));
11572 if (SWIG_arg_fail(4)) SWIG_fail;
11573 }
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11584 }
11585 {
11586 if (temp2)
11587 delete arg2;
11588 }
11589 return resultobj;
11590 fail:
11591 {
11592 if (temp2)
11593 delete arg2;
11594 }
11595 return NULL;
11596 }
11597
11598
11599 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11600 PyObject *resultobj;
11601 wxImage *arg1 = (wxImage *) 0 ;
11602 wxString *arg2 = 0 ;
11603 wxString *arg3 = 0 ;
11604 int arg4 = (int) -1 ;
11605 bool result;
11606 bool temp2 = false ;
11607 bool temp3 = false ;
11608 PyObject * obj0 = 0 ;
11609 PyObject * obj1 = 0 ;
11610 PyObject * obj2 = 0 ;
11611 PyObject * obj3 = 0 ;
11612 char *kwnames[] = {
11613 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11614 };
11615
11616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11618 if (SWIG_arg_fail(1)) SWIG_fail;
11619 {
11620 arg2 = wxString_in_helper(obj1);
11621 if (arg2 == NULL) SWIG_fail;
11622 temp2 = true;
11623 }
11624 {
11625 arg3 = wxString_in_helper(obj2);
11626 if (arg3 == NULL) SWIG_fail;
11627 temp3 = true;
11628 }
11629 if (obj3) {
11630 {
11631 arg4 = (int)(SWIG_As_int(obj3));
11632 if (SWIG_arg_fail(4)) SWIG_fail;
11633 }
11634 }
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11638
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11644 }
11645 {
11646 if (temp2)
11647 delete arg2;
11648 }
11649 {
11650 if (temp3)
11651 delete arg3;
11652 }
11653 return resultobj;
11654 fail:
11655 {
11656 if (temp2)
11657 delete arg2;
11658 }
11659 {
11660 if (temp3)
11661 delete arg3;
11662 }
11663 return NULL;
11664 }
11665
11666
11667 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj;
11669 wxImage *arg1 = (wxImage *) 0 ;
11670 wxString *arg2 = 0 ;
11671 int arg3 ;
11672 bool result;
11673 bool temp2 = false ;
11674 PyObject * obj0 = 0 ;
11675 PyObject * obj1 = 0 ;
11676 PyObject * obj2 = 0 ;
11677 char *kwnames[] = {
11678 (char *) "self",(char *) "name",(char *) "type", NULL
11679 };
11680
11681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11683 if (SWIG_arg_fail(1)) SWIG_fail;
11684 {
11685 arg2 = wxString_in_helper(obj1);
11686 if (arg2 == NULL) SWIG_fail;
11687 temp2 = true;
11688 }
11689 {
11690 arg3 = (int)(SWIG_As_int(obj2));
11691 if (SWIG_arg_fail(3)) SWIG_fail;
11692 }
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11696
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 {
11701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11702 }
11703 {
11704 if (temp2)
11705 delete arg2;
11706 }
11707 return resultobj;
11708 fail:
11709 {
11710 if (temp2)
11711 delete arg2;
11712 }
11713 return NULL;
11714 }
11715
11716
11717 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj;
11719 wxImage *arg1 = (wxImage *) 0 ;
11720 wxString *arg2 = 0 ;
11721 wxString *arg3 = 0 ;
11722 bool result;
11723 bool temp2 = false ;
11724 bool temp3 = false ;
11725 PyObject * obj0 = 0 ;
11726 PyObject * obj1 = 0 ;
11727 PyObject * obj2 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 arg2 = wxString_in_helper(obj1);
11737 if (arg2 == NULL) SWIG_fail;
11738 temp2 = true;
11739 }
11740 {
11741 arg3 = wxString_in_helper(obj2);
11742 if (arg3 == NULL) SWIG_fail;
11743 temp3 = true;
11744 }
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11748
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 {
11753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11754 }
11755 {
11756 if (temp2)
11757 delete arg2;
11758 }
11759 {
11760 if (temp3)
11761 delete arg3;
11762 }
11763 return resultobj;
11764 fail:
11765 {
11766 if (temp2)
11767 delete arg2;
11768 }
11769 {
11770 if (temp3)
11771 delete arg3;
11772 }
11773 return NULL;
11774 }
11775
11776
11777 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11778 PyObject *resultobj;
11779 wxInputStream *arg1 = 0 ;
11780 bool result;
11781 wxPyInputStream *temp1 ;
11782 bool created1 ;
11783 PyObject * obj0 = 0 ;
11784 char *kwnames[] = {
11785 (char *) "stream", NULL
11786 };
11787
11788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11789 {
11790 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11791 arg1 = temp1->m_wxis;
11792 created1 = false;
11793 } else {
11794 PyErr_Clear(); // clear the failure of the wxPyConvert above
11795 arg1 = wxPyCBInputStream_create(obj0, false);
11796 if (arg1 == NULL) {
11797 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11798 SWIG_fail;
11799 }
11800 created1 = true;
11801 }
11802 }
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (bool)wxImage::CanRead(*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 (created1) delete arg1;
11815 }
11816 return resultobj;
11817 fail:
11818 {
11819 if (created1) delete arg1;
11820 }
11821 return NULL;
11822 }
11823
11824
11825 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11826 PyObject *resultobj;
11827 wxImage *arg1 = (wxImage *) 0 ;
11828 wxInputStream *arg2 = 0 ;
11829 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11830 int arg4 = (int) -1 ;
11831 bool result;
11832 wxPyInputStream *temp2 ;
11833 bool created2 ;
11834 PyObject * obj0 = 0 ;
11835 PyObject * obj1 = 0 ;
11836 PyObject * obj2 = 0 ;
11837 PyObject * obj3 = 0 ;
11838 char *kwnames[] = {
11839 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11840 };
11841
11842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11844 if (SWIG_arg_fail(1)) SWIG_fail;
11845 {
11846 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11847 arg2 = temp2->m_wxis;
11848 created2 = false;
11849 } else {
11850 PyErr_Clear(); // clear the failure of the wxPyConvert above
11851 arg2 = wxPyCBInputStream_create(obj1, false);
11852 if (arg2 == NULL) {
11853 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11854 SWIG_fail;
11855 }
11856 created2 = true;
11857 }
11858 }
11859 if (obj2) {
11860 {
11861 arg3 = (long)(SWIG_As_long(obj2));
11862 if (SWIG_arg_fail(3)) SWIG_fail;
11863 }
11864 }
11865 if (obj3) {
11866 {
11867 arg4 = (int)(SWIG_As_int(obj3));
11868 if (SWIG_arg_fail(4)) SWIG_fail;
11869 }
11870 }
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 {
11882 if (created2) delete arg2;
11883 }
11884 return resultobj;
11885 fail:
11886 {
11887 if (created2) delete arg2;
11888 }
11889 return NULL;
11890 }
11891
11892
11893 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj;
11895 wxImage *arg1 = (wxImage *) 0 ;
11896 wxInputStream *arg2 = 0 ;
11897 wxString *arg3 = 0 ;
11898 int arg4 = (int) -1 ;
11899 bool result;
11900 wxPyInputStream *temp2 ;
11901 bool created2 ;
11902 bool temp3 = false ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 PyObject * obj2 = 0 ;
11906 PyObject * obj3 = 0 ;
11907 char *kwnames[] = {
11908 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11909 };
11910
11911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11913 if (SWIG_arg_fail(1)) SWIG_fail;
11914 {
11915 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11916 arg2 = temp2->m_wxis;
11917 created2 = false;
11918 } else {
11919 PyErr_Clear(); // clear the failure of the wxPyConvert above
11920 arg2 = wxPyCBInputStream_create(obj1, false);
11921 if (arg2 == NULL) {
11922 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11923 SWIG_fail;
11924 }
11925 created2 = true;
11926 }
11927 }
11928 {
11929 arg3 = wxString_in_helper(obj2);
11930 if (arg3 == NULL) SWIG_fail;
11931 temp3 = true;
11932 }
11933 if (obj3) {
11934 {
11935 arg4 = (int)(SWIG_As_int(obj3));
11936 if (SWIG_arg_fail(4)) SWIG_fail;
11937 }
11938 }
11939 {
11940 PyThreadState* __tstate = wxPyBeginAllowThreads();
11941 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11942
11943 wxPyEndAllowThreads(__tstate);
11944 if (PyErr_Occurred()) SWIG_fail;
11945 }
11946 {
11947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11948 }
11949 {
11950 if (created2) delete arg2;
11951 }
11952 {
11953 if (temp3)
11954 delete arg3;
11955 }
11956 return resultobj;
11957 fail:
11958 {
11959 if (created2) delete arg2;
11960 }
11961 {
11962 if (temp3)
11963 delete arg3;
11964 }
11965 return NULL;
11966 }
11967
11968
11969 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj;
11971 wxImage *arg1 = (wxImage *) 0 ;
11972 bool result;
11973 PyObject * obj0 = 0 ;
11974 char *kwnames[] = {
11975 (char *) "self", NULL
11976 };
11977
11978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11980 if (SWIG_arg_fail(1)) SWIG_fail;
11981 {
11982 PyThreadState* __tstate = wxPyBeginAllowThreads();
11983 result = (bool)(arg1)->Ok();
11984
11985 wxPyEndAllowThreads(__tstate);
11986 if (PyErr_Occurred()) SWIG_fail;
11987 }
11988 {
11989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11990 }
11991 return resultobj;
11992 fail:
11993 return NULL;
11994 }
11995
11996
11997 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11998 PyObject *resultobj;
11999 wxImage *arg1 = (wxImage *) 0 ;
12000 int result;
12001 PyObject * obj0 = 0 ;
12002 char *kwnames[] = {
12003 (char *) "self", NULL
12004 };
12005
12006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12008 if (SWIG_arg_fail(1)) SWIG_fail;
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (int)(arg1)->GetWidth();
12012
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = SWIG_From_int((int)(result));
12018 }
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj;
12027 wxImage *arg1 = (wxImage *) 0 ;
12028 int result;
12029 PyObject * obj0 = 0 ;
12030 char *kwnames[] = {
12031 (char *) "self", NULL
12032 };
12033
12034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12036 if (SWIG_arg_fail(1)) SWIG_fail;
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (int)(arg1)->GetHeight();
12040
12041 wxPyEndAllowThreads(__tstate);
12042 if (PyErr_Occurred()) SWIG_fail;
12043 }
12044 {
12045 resultobj = SWIG_From_int((int)(result));
12046 }
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxImage *arg1 = (wxImage *) 0 ;
12056 wxSize result;
12057 PyObject * obj0 = 0 ;
12058 char *kwnames[] = {
12059 (char *) "self", NULL
12060 };
12061
12062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12064 if (SWIG_arg_fail(1)) SWIG_fail;
12065 {
12066 PyThreadState* __tstate = wxPyBeginAllowThreads();
12067 result = wxImage_GetSize(arg1);
12068
12069 wxPyEndAllowThreads(__tstate);
12070 if (PyErr_Occurred()) SWIG_fail;
12071 }
12072 {
12073 wxSize * resultptr;
12074 resultptr = new wxSize((wxSize &)(result));
12075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12076 }
12077 return resultobj;
12078 fail:
12079 return NULL;
12080 }
12081
12082
12083 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12084 PyObject *resultobj;
12085 wxImage *arg1 = (wxImage *) 0 ;
12086 wxRect *arg2 = 0 ;
12087 SwigValueWrapper<wxImage > result;
12088 wxRect temp2 ;
12089 PyObject * obj0 = 0 ;
12090 PyObject * obj1 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self",(char *) "rect", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 arg2 = &temp2;
12100 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12101 }
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12105
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 {
12110 wxImage * resultptr;
12111 resultptr = new wxImage((wxImage &)(result));
12112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12113 }
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj;
12122 wxImage *arg1 = (wxImage *) 0 ;
12123 SwigValueWrapper<wxImage > result;
12124 PyObject * obj0 = 0 ;
12125 char *kwnames[] = {
12126 (char *) "self", NULL
12127 };
12128
12129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12131 if (SWIG_arg_fail(1)) SWIG_fail;
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = (arg1)->Copy();
12135
12136 wxPyEndAllowThreads(__tstate);
12137 if (PyErr_Occurred()) SWIG_fail;
12138 }
12139 {
12140 wxImage * resultptr;
12141 resultptr = new wxImage((wxImage &)(result));
12142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12143 }
12144 return resultobj;
12145 fail:
12146 return NULL;
12147 }
12148
12149
12150 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12151 PyObject *resultobj;
12152 wxImage *arg1 = (wxImage *) 0 ;
12153 wxImage *arg2 = 0 ;
12154 int arg3 ;
12155 int arg4 ;
12156 PyObject * obj0 = 0 ;
12157 PyObject * obj1 = 0 ;
12158 PyObject * obj2 = 0 ;
12159 PyObject * obj3 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12166 if (SWIG_arg_fail(1)) SWIG_fail;
12167 {
12168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12169 if (SWIG_arg_fail(2)) SWIG_fail;
12170 if (arg2 == NULL) {
12171 SWIG_null_ref("wxImage");
12172 }
12173 if (SWIG_arg_fail(2)) SWIG_fail;
12174 }
12175 {
12176 arg3 = (int)(SWIG_As_int(obj2));
12177 if (SWIG_arg_fail(3)) SWIG_fail;
12178 }
12179 {
12180 arg4 = (int)(SWIG_As_int(obj3));
12181 if (SWIG_arg_fail(4)) SWIG_fail;
12182 }
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12186
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 Py_INCREF(Py_None); resultobj = Py_None;
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj;
12199 wxImage *arg1 = (wxImage *) 0 ;
12200 PyObject *result;
12201 PyObject * obj0 = 0 ;
12202 char *kwnames[] = {
12203 (char *) "self", NULL
12204 };
12205
12206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12208 if (SWIG_arg_fail(1)) SWIG_fail;
12209 {
12210 PyThreadState* __tstate = wxPyBeginAllowThreads();
12211 result = (PyObject *)wxImage_GetData(arg1);
12212
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 resultobj = result;
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj;
12225 wxImage *arg1 = (wxImage *) 0 ;
12226 PyObject *arg2 = (PyObject *) 0 ;
12227 PyObject * obj0 = 0 ;
12228 PyObject * obj1 = 0 ;
12229 char *kwnames[] = {
12230 (char *) "self",(char *) "data", NULL
12231 };
12232
12233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12235 if (SWIG_arg_fail(1)) SWIG_fail;
12236 arg2 = obj1;
12237 {
12238 PyThreadState* __tstate = wxPyBeginAllowThreads();
12239 wxImage_SetData(arg1,arg2);
12240
12241 wxPyEndAllowThreads(__tstate);
12242 if (PyErr_Occurred()) SWIG_fail;
12243 }
12244 Py_INCREF(Py_None); resultobj = Py_None;
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj;
12253 wxImage *arg1 = (wxImage *) 0 ;
12254 PyObject *result;
12255 PyObject * obj0 = 0 ;
12256 char *kwnames[] = {
12257 (char *) "self", NULL
12258 };
12259
12260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12262 if (SWIG_arg_fail(1)) SWIG_fail;
12263 {
12264 PyThreadState* __tstate = wxPyBeginAllowThreads();
12265 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12266
12267 wxPyEndAllowThreads(__tstate);
12268 if (PyErr_Occurred()) SWIG_fail;
12269 }
12270 resultobj = result;
12271 return resultobj;
12272 fail:
12273 return NULL;
12274 }
12275
12276
12277 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12278 PyObject *resultobj;
12279 wxImage *arg1 = (wxImage *) 0 ;
12280 PyObject *arg2 = (PyObject *) 0 ;
12281 PyObject * obj0 = 0 ;
12282 PyObject * obj1 = 0 ;
12283 char *kwnames[] = {
12284 (char *) "self",(char *) "data", NULL
12285 };
12286
12287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12289 if (SWIG_arg_fail(1)) SWIG_fail;
12290 arg2 = obj1;
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 wxImage_SetDataBuffer(arg1,arg2);
12294
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 Py_INCREF(Py_None); resultobj = Py_None;
12299 return resultobj;
12300 fail:
12301 return NULL;
12302 }
12303
12304
12305 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj;
12307 wxImage *arg1 = (wxImage *) 0 ;
12308 PyObject *result;
12309 PyObject * obj0 = 0 ;
12310 char *kwnames[] = {
12311 (char *) "self", NULL
12312 };
12313
12314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",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 = (PyObject *)wxImage_GetAlphaData(arg1);
12320
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = result;
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12332 PyObject *resultobj;
12333 wxImage *arg1 = (wxImage *) 0 ;
12334 PyObject *arg2 = (PyObject *) 0 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 char *kwnames[] = {
12338 (char *) "self",(char *) "data", NULL
12339 };
12340
12341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12343 if (SWIG_arg_fail(1)) SWIG_fail;
12344 arg2 = obj1;
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 wxImage_SetAlphaData(arg1,arg2);
12348
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 Py_INCREF(Py_None); resultobj = Py_None;
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj;
12361 wxImage *arg1 = (wxImage *) 0 ;
12362 PyObject *result;
12363 PyObject * obj0 = 0 ;
12364 char *kwnames[] = {
12365 (char *) "self", NULL
12366 };
12367
12368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12370 if (SWIG_arg_fail(1)) SWIG_fail;
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12374
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 resultobj = result;
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj;
12387 wxImage *arg1 = (wxImage *) 0 ;
12388 PyObject *arg2 = (PyObject *) 0 ;
12389 PyObject * obj0 = 0 ;
12390 PyObject * obj1 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self",(char *) "data", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 arg2 = obj1;
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 wxImage_SetAlphaBuffer(arg1,arg2);
12402
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 Py_INCREF(Py_None); resultobj = Py_None;
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj;
12415 wxImage *arg1 = (wxImage *) 0 ;
12416 unsigned char arg2 ;
12417 unsigned char arg3 ;
12418 unsigned char arg4 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 PyObject * obj3 = 0 ;
12423 char *kwnames[] = {
12424 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12425 };
12426
12427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12429 if (SWIG_arg_fail(1)) SWIG_fail;
12430 {
12431 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12432 if (SWIG_arg_fail(2)) SWIG_fail;
12433 }
12434 {
12435 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12436 if (SWIG_arg_fail(3)) SWIG_fail;
12437 }
12438 {
12439 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12440 if (SWIG_arg_fail(4)) SWIG_fail;
12441 }
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 (arg1)->SetMaskColour(arg2,arg3,arg4);
12445
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 Py_INCREF(Py_None); resultobj = Py_None;
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj;
12458 wxImage *arg1 = (wxImage *) 0 ;
12459 unsigned char result;
12460 PyObject * obj0 = 0 ;
12461 char *kwnames[] = {
12462 (char *) "self", NULL
12463 };
12464
12465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12467 if (SWIG_arg_fail(1)) SWIG_fail;
12468 {
12469 PyThreadState* __tstate = wxPyBeginAllowThreads();
12470 result = (unsigned char)(arg1)->GetMaskRed();
12471
12472 wxPyEndAllowThreads(__tstate);
12473 if (PyErr_Occurred()) SWIG_fail;
12474 }
12475 {
12476 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12477 }
12478 return resultobj;
12479 fail:
12480 return NULL;
12481 }
12482
12483
12484 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12485 PyObject *resultobj;
12486 wxImage *arg1 = (wxImage *) 0 ;
12487 unsigned char result;
12488 PyObject * obj0 = 0 ;
12489 char *kwnames[] = {
12490 (char *) "self", NULL
12491 };
12492
12493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12495 if (SWIG_arg_fail(1)) SWIG_fail;
12496 {
12497 PyThreadState* __tstate = wxPyBeginAllowThreads();
12498 result = (unsigned char)(arg1)->GetMaskGreen();
12499
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 {
12504 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12505 }
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12513 PyObject *resultobj;
12514 wxImage *arg1 = (wxImage *) 0 ;
12515 unsigned char result;
12516 PyObject * obj0 = 0 ;
12517 char *kwnames[] = {
12518 (char *) "self", NULL
12519 };
12520
12521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12523 if (SWIG_arg_fail(1)) SWIG_fail;
12524 {
12525 PyThreadState* __tstate = wxPyBeginAllowThreads();
12526 result = (unsigned char)(arg1)->GetMaskBlue();
12527
12528 wxPyEndAllowThreads(__tstate);
12529 if (PyErr_Occurred()) SWIG_fail;
12530 }
12531 {
12532 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12533 }
12534 return resultobj;
12535 fail:
12536 return NULL;
12537 }
12538
12539
12540 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12541 PyObject *resultobj;
12542 wxImage *arg1 = (wxImage *) 0 ;
12543 bool arg2 = (bool) true ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 char *kwnames[] = {
12547 (char *) "self",(char *) "mask", NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12552 if (SWIG_arg_fail(1)) SWIG_fail;
12553 if (obj1) {
12554 {
12555 arg2 = (bool)(SWIG_As_bool(obj1));
12556 if (SWIG_arg_fail(2)) SWIG_fail;
12557 }
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 (arg1)->SetMask(arg2);
12562
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 Py_INCREF(Py_None); resultobj = Py_None;
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxImage *arg1 = (wxImage *) 0 ;
12576 bool result;
12577 PyObject * obj0 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (bool)(arg1)->HasMask();
12588
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj;
12603 wxImage *arg1 = (wxImage *) 0 ;
12604 double arg2 ;
12605 wxPoint *arg3 = 0 ;
12606 bool arg4 = (bool) true ;
12607 wxPoint *arg5 = (wxPoint *) NULL ;
12608 SwigValueWrapper<wxImage > result;
12609 wxPoint temp3 ;
12610 PyObject * obj0 = 0 ;
12611 PyObject * obj1 = 0 ;
12612 PyObject * obj2 = 0 ;
12613 PyObject * obj3 = 0 ;
12614 PyObject * obj4 = 0 ;
12615 char *kwnames[] = {
12616 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12617 };
12618
12619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12621 if (SWIG_arg_fail(1)) SWIG_fail;
12622 {
12623 arg2 = (double)(SWIG_As_double(obj1));
12624 if (SWIG_arg_fail(2)) SWIG_fail;
12625 }
12626 {
12627 arg3 = &temp3;
12628 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12629 }
12630 if (obj3) {
12631 {
12632 arg4 = (bool)(SWIG_As_bool(obj3));
12633 if (SWIG_arg_fail(4)) SWIG_fail;
12634 }
12635 }
12636 if (obj4) {
12637 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12638 if (SWIG_arg_fail(5)) SWIG_fail;
12639 }
12640 {
12641 PyThreadState* __tstate = wxPyBeginAllowThreads();
12642 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12643
12644 wxPyEndAllowThreads(__tstate);
12645 if (PyErr_Occurred()) SWIG_fail;
12646 }
12647 {
12648 wxImage * resultptr;
12649 resultptr = new wxImage((wxImage &)(result));
12650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12651 }
12652 return resultobj;
12653 fail:
12654 return NULL;
12655 }
12656
12657
12658 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12659 PyObject *resultobj;
12660 wxImage *arg1 = (wxImage *) 0 ;
12661 bool arg2 = (bool) true ;
12662 SwigValueWrapper<wxImage > result;
12663 PyObject * obj0 = 0 ;
12664 PyObject * obj1 = 0 ;
12665 char *kwnames[] = {
12666 (char *) "self",(char *) "clockwise", NULL
12667 };
12668
12669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12671 if (SWIG_arg_fail(1)) SWIG_fail;
12672 if (obj1) {
12673 {
12674 arg2 = (bool)(SWIG_As_bool(obj1));
12675 if (SWIG_arg_fail(2)) SWIG_fail;
12676 }
12677 }
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (arg1)->Rotate90(arg2);
12681
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 wxImage * resultptr;
12687 resultptr = new wxImage((wxImage &)(result));
12688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12689 }
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxImage *arg1 = (wxImage *) 0 ;
12699 bool arg2 = (bool) true ;
12700 SwigValueWrapper<wxImage > result;
12701 PyObject * obj0 = 0 ;
12702 PyObject * obj1 = 0 ;
12703 char *kwnames[] = {
12704 (char *) "self",(char *) "horizontally", NULL
12705 };
12706
12707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(1)) SWIG_fail;
12710 if (obj1) {
12711 {
12712 arg2 = (bool)(SWIG_As_bool(obj1));
12713 if (SWIG_arg_fail(2)) SWIG_fail;
12714 }
12715 }
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 result = (arg1)->Mirror(arg2);
12719
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 {
12724 wxImage * resultptr;
12725 resultptr = new wxImage((wxImage &)(result));
12726 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12727 }
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12735 PyObject *resultobj;
12736 wxImage *arg1 = (wxImage *) 0 ;
12737 unsigned char arg2 ;
12738 unsigned char arg3 ;
12739 unsigned char arg4 ;
12740 unsigned char arg5 ;
12741 unsigned char arg6 ;
12742 unsigned char arg7 ;
12743 PyObject * obj0 = 0 ;
12744 PyObject * obj1 = 0 ;
12745 PyObject * obj2 = 0 ;
12746 PyObject * obj3 = 0 ;
12747 PyObject * obj4 = 0 ;
12748 PyObject * obj5 = 0 ;
12749 PyObject * obj6 = 0 ;
12750 char *kwnames[] = {
12751 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12752 };
12753
12754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12756 if (SWIG_arg_fail(1)) SWIG_fail;
12757 {
12758 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12759 if (SWIG_arg_fail(2)) SWIG_fail;
12760 }
12761 {
12762 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12763 if (SWIG_arg_fail(3)) SWIG_fail;
12764 }
12765 {
12766 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12767 if (SWIG_arg_fail(4)) SWIG_fail;
12768 }
12769 {
12770 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12771 if (SWIG_arg_fail(5)) SWIG_fail;
12772 }
12773 {
12774 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12775 if (SWIG_arg_fail(6)) SWIG_fail;
12776 }
12777 {
12778 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12779 if (SWIG_arg_fail(7)) SWIG_fail;
12780 }
12781 {
12782 PyThreadState* __tstate = wxPyBeginAllowThreads();
12783 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12784
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 Py_INCREF(Py_None); resultobj = Py_None;
12789 return resultobj;
12790 fail:
12791 return NULL;
12792 }
12793
12794
12795 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12796 PyObject *resultobj;
12797 wxImage *arg1 = (wxImage *) 0 ;
12798 unsigned char arg2 ;
12799 unsigned char arg3 ;
12800 unsigned char arg4 ;
12801 SwigValueWrapper<wxImage > result;
12802 PyObject * obj0 = 0 ;
12803 PyObject * obj1 = 0 ;
12804 PyObject * obj2 = 0 ;
12805 PyObject * obj3 = 0 ;
12806 char *kwnames[] = {
12807 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12808 };
12809
12810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12812 if (SWIG_arg_fail(1)) SWIG_fail;
12813 {
12814 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12815 if (SWIG_arg_fail(2)) SWIG_fail;
12816 }
12817 {
12818 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12819 if (SWIG_arg_fail(3)) SWIG_fail;
12820 }
12821 {
12822 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12823 if (SWIG_arg_fail(4)) SWIG_fail;
12824 }
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12828
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 {
12833 wxImage * resultptr;
12834 resultptr = new wxImage((wxImage &)(result));
12835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12836 }
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj;
12845 wxImage *arg1 = (wxImage *) 0 ;
12846 wxString *arg2 = 0 ;
12847 wxString *arg3 = 0 ;
12848 bool temp2 = false ;
12849 bool temp3 = false ;
12850 PyObject * obj0 = 0 ;
12851 PyObject * obj1 = 0 ;
12852 PyObject * obj2 = 0 ;
12853 char *kwnames[] = {
12854 (char *) "self",(char *) "name",(char *) "value", NULL
12855 };
12856
12857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12859 if (SWIG_arg_fail(1)) SWIG_fail;
12860 {
12861 arg2 = wxString_in_helper(obj1);
12862 if (arg2 == NULL) SWIG_fail;
12863 temp2 = true;
12864 }
12865 {
12866 arg3 = wxString_in_helper(obj2);
12867 if (arg3 == NULL) SWIG_fail;
12868 temp3 = true;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12873
12874 wxPyEndAllowThreads(__tstate);
12875 if (PyErr_Occurred()) SWIG_fail;
12876 }
12877 Py_INCREF(Py_None); resultobj = Py_None;
12878 {
12879 if (temp2)
12880 delete arg2;
12881 }
12882 {
12883 if (temp3)
12884 delete arg3;
12885 }
12886 return resultobj;
12887 fail:
12888 {
12889 if (temp2)
12890 delete arg2;
12891 }
12892 {
12893 if (temp3)
12894 delete arg3;
12895 }
12896 return NULL;
12897 }
12898
12899
12900 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj;
12902 wxImage *arg1 = (wxImage *) 0 ;
12903 wxString *arg2 = 0 ;
12904 int arg3 ;
12905 bool temp2 = false ;
12906 PyObject * obj0 = 0 ;
12907 PyObject * obj1 = 0 ;
12908 PyObject * obj2 = 0 ;
12909 char *kwnames[] = {
12910 (char *) "self",(char *) "name",(char *) "value", NULL
12911 };
12912
12913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12915 if (SWIG_arg_fail(1)) SWIG_fail;
12916 {
12917 arg2 = wxString_in_helper(obj1);
12918 if (arg2 == NULL) SWIG_fail;
12919 temp2 = true;
12920 }
12921 {
12922 arg3 = (int)(SWIG_As_int(obj2));
12923 if (SWIG_arg_fail(3)) SWIG_fail;
12924 }
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 (arg1)->SetOption((wxString const &)*arg2,arg3);
12928
12929 wxPyEndAllowThreads(__tstate);
12930 if (PyErr_Occurred()) SWIG_fail;
12931 }
12932 Py_INCREF(Py_None); resultobj = Py_None;
12933 {
12934 if (temp2)
12935 delete arg2;
12936 }
12937 return resultobj;
12938 fail:
12939 {
12940 if (temp2)
12941 delete arg2;
12942 }
12943 return NULL;
12944 }
12945
12946
12947 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12948 PyObject *resultobj;
12949 wxImage *arg1 = (wxImage *) 0 ;
12950 wxString *arg2 = 0 ;
12951 wxString result;
12952 bool temp2 = false ;
12953 PyObject * obj0 = 0 ;
12954 PyObject * obj1 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self",(char *) "name", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12961 if (SWIG_arg_fail(1)) SWIG_fail;
12962 {
12963 arg2 = wxString_in_helper(obj1);
12964 if (arg2 == NULL) SWIG_fail;
12965 temp2 = true;
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 #if wxUSE_UNICODE
12976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12977 #else
12978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12979 #endif
12980 }
12981 {
12982 if (temp2)
12983 delete arg2;
12984 }
12985 return resultobj;
12986 fail:
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return NULL;
12992 }
12993
12994
12995 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12996 PyObject *resultobj;
12997 wxImage *arg1 = (wxImage *) 0 ;
12998 wxString *arg2 = 0 ;
12999 int result;
13000 bool temp2 = false ;
13001 PyObject * obj0 = 0 ;
13002 PyObject * obj1 = 0 ;
13003 char *kwnames[] = {
13004 (char *) "self",(char *) "name", NULL
13005 };
13006
13007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13009 if (SWIG_arg_fail(1)) SWIG_fail;
13010 {
13011 arg2 = wxString_in_helper(obj1);
13012 if (arg2 == NULL) SWIG_fail;
13013 temp2 = true;
13014 }
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13018
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 {
13023 resultobj = SWIG_From_int((int)(result));
13024 }
13025 {
13026 if (temp2)
13027 delete arg2;
13028 }
13029 return resultobj;
13030 fail:
13031 {
13032 if (temp2)
13033 delete arg2;
13034 }
13035 return NULL;
13036 }
13037
13038
13039 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13040 PyObject *resultobj;
13041 wxImage *arg1 = (wxImage *) 0 ;
13042 wxString *arg2 = 0 ;
13043 bool result;
13044 bool temp2 = false ;
13045 PyObject * obj0 = 0 ;
13046 PyObject * obj1 = 0 ;
13047 char *kwnames[] = {
13048 (char *) "self",(char *) "name", NULL
13049 };
13050
13051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13053 if (SWIG_arg_fail(1)) SWIG_fail;
13054 {
13055 arg2 = wxString_in_helper(obj1);
13056 if (arg2 == NULL) SWIG_fail;
13057 temp2 = true;
13058 }
13059 {
13060 PyThreadState* __tstate = wxPyBeginAllowThreads();
13061 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13062
13063 wxPyEndAllowThreads(__tstate);
13064 if (PyErr_Occurred()) SWIG_fail;
13065 }
13066 {
13067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13068 }
13069 {
13070 if (temp2)
13071 delete arg2;
13072 }
13073 return resultobj;
13074 fail:
13075 {
13076 if (temp2)
13077 delete arg2;
13078 }
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13087 unsigned long result;
13088 PyObject * obj0 = 0 ;
13089 PyObject * obj1 = 0 ;
13090 char *kwnames[] = {
13091 (char *) "self",(char *) "stopafter", NULL
13092 };
13093
13094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(1)) SWIG_fail;
13097 if (obj1) {
13098 {
13099 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13100 if (SWIG_arg_fail(2)) SWIG_fail;
13101 }
13102 }
13103 {
13104 PyThreadState* __tstate = wxPyBeginAllowThreads();
13105 result = (unsigned long)(arg1)->CountColours(arg2);
13106
13107 wxPyEndAllowThreads(__tstate);
13108 if (PyErr_Occurred()) SWIG_fail;
13109 }
13110 {
13111 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13112 }
13113 return resultobj;
13114 fail:
13115 return NULL;
13116 }
13117
13118
13119 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13120 PyObject *resultobj;
13121 wxImage *arg1 = (wxImage *) 0 ;
13122 wxImageHistogram *arg2 = 0 ;
13123 unsigned long result;
13124 PyObject * obj0 = 0 ;
13125 PyObject * obj1 = 0 ;
13126 char *kwnames[] = {
13127 (char *) "self",(char *) "h", NULL
13128 };
13129
13130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13132 if (SWIG_arg_fail(1)) SWIG_fail;
13133 {
13134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(2)) SWIG_fail;
13136 if (arg2 == NULL) {
13137 SWIG_null_ref("wxImageHistogram");
13138 }
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13144
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 {
13149 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13150 }
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13158 PyObject *resultobj;
13159 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13160 PyObject * obj0 = 0 ;
13161 char *kwnames[] = {
13162 (char *) "handler", NULL
13163 };
13164
13165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13167 if (SWIG_arg_fail(1)) SWIG_fail;
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 wxImage::AddHandler(arg1);
13171
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 Py_INCREF(Py_None); resultobj = Py_None;
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj;
13184 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13185 PyObject * obj0 = 0 ;
13186 char *kwnames[] = {
13187 (char *) "handler", NULL
13188 };
13189
13190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13192 if (SWIG_arg_fail(1)) SWIG_fail;
13193 {
13194 PyThreadState* __tstate = wxPyBeginAllowThreads();
13195 wxImage::InsertHandler(arg1);
13196
13197 wxPyEndAllowThreads(__tstate);
13198 if (PyErr_Occurred()) SWIG_fail;
13199 }
13200 Py_INCREF(Py_None); resultobj = Py_None;
13201 return resultobj;
13202 fail:
13203 return NULL;
13204 }
13205
13206
13207 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13208 PyObject *resultobj;
13209 wxString *arg1 = 0 ;
13210 bool result;
13211 bool temp1 = false ;
13212 PyObject * obj0 = 0 ;
13213 char *kwnames[] = {
13214 (char *) "name", NULL
13215 };
13216
13217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13218 {
13219 arg1 = wxString_in_helper(obj0);
13220 if (arg1 == NULL) SWIG_fail;
13221 temp1 = true;
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 {
13231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13232 }
13233 {
13234 if (temp1)
13235 delete arg1;
13236 }
13237 return resultobj;
13238 fail:
13239 {
13240 if (temp1)
13241 delete arg1;
13242 }
13243 return NULL;
13244 }
13245
13246
13247 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj;
13249 wxString result;
13250 char *kwnames[] = {
13251 NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = wxImage::GetImageExtWildcard();
13258
13259 wxPyEndAllowThreads(__tstate);
13260 if (PyErr_Occurred()) SWIG_fail;
13261 }
13262 {
13263 #if wxUSE_UNICODE
13264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13265 #else
13266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13267 #endif
13268 }
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj;
13277 wxImage *arg1 = (wxImage *) 0 ;
13278 int arg2 = (int) -1 ;
13279 wxBitmap result;
13280 PyObject * obj0 = 0 ;
13281 PyObject * obj1 = 0 ;
13282 char *kwnames[] = {
13283 (char *) "self",(char *) "depth", NULL
13284 };
13285
13286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13288 if (SWIG_arg_fail(1)) SWIG_fail;
13289 if (obj1) {
13290 {
13291 arg2 = (int)(SWIG_As_int(obj1));
13292 if (SWIG_arg_fail(2)) SWIG_fail;
13293 }
13294 }
13295 {
13296 if (!wxPyCheckForApp()) SWIG_fail;
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 result = wxImage_ConvertToBitmap(arg1,arg2);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 {
13304 wxBitmap * resultptr;
13305 resultptr = new wxBitmap((wxBitmap &)(result));
13306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13307 }
13308 return resultobj;
13309 fail:
13310 return NULL;
13311 }
13312
13313
13314 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj;
13316 wxImage *arg1 = (wxImage *) 0 ;
13317 unsigned char arg2 ;
13318 unsigned char arg3 ;
13319 unsigned char arg4 ;
13320 wxBitmap result;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 PyObject * obj2 = 0 ;
13324 PyObject * obj3 = 0 ;
13325 char *kwnames[] = {
13326 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13327 };
13328
13329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13331 if (SWIG_arg_fail(1)) SWIG_fail;
13332 {
13333 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13334 if (SWIG_arg_fail(2)) SWIG_fail;
13335 }
13336 {
13337 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13338 if (SWIG_arg_fail(3)) SWIG_fail;
13339 }
13340 {
13341 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13342 if (SWIG_arg_fail(4)) SWIG_fail;
13343 }
13344 {
13345 if (!wxPyCheckForApp()) SWIG_fail;
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13348
13349 wxPyEndAllowThreads(__tstate);
13350 if (PyErr_Occurred()) SWIG_fail;
13351 }
13352 {
13353 wxBitmap * resultptr;
13354 resultptr = new wxBitmap((wxBitmap &)(result));
13355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13356 }
13357 return resultobj;
13358 fail:
13359 return NULL;
13360 }
13361
13362
13363 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13364 PyObject *obj;
13365 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13366 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13367 Py_INCREF(obj);
13368 return Py_BuildValue((char *)"");
13369 }
13370 static int _wrap_NullImage_set(PyObject *) {
13371 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13372 return 1;
13373 }
13374
13375
13376 static PyObject *_wrap_NullImage_get(void) {
13377 PyObject *pyobj;
13378
13379 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13380 return pyobj;
13381 }
13382
13383
13384 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13385 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13386 return 1;
13387 }
13388
13389
13390 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13391 PyObject *pyobj;
13392
13393 {
13394 #if wxUSE_UNICODE
13395 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13396 #else
13397 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13398 #endif
13399 }
13400 return pyobj;
13401 }
13402
13403
13404 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13405 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13406 return 1;
13407 }
13408
13409
13410 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13411 PyObject *pyobj;
13412
13413 {
13414 #if wxUSE_UNICODE
13415 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13416 #else
13417 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13418 #endif
13419 }
13420 return pyobj;
13421 }
13422
13423
13424 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13425 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13426 return 1;
13427 }
13428
13429
13430 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13431 PyObject *pyobj;
13432
13433 {
13434 #if wxUSE_UNICODE
13435 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13436 #else
13437 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13438 #endif
13439 }
13440 return pyobj;
13441 }
13442
13443
13444 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13445 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13446 return 1;
13447 }
13448
13449
13450 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13451 PyObject *pyobj;
13452
13453 {
13454 #if wxUSE_UNICODE
13455 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13456 #else
13457 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13458 #endif
13459 }
13460 return pyobj;
13461 }
13462
13463
13464 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13465 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13466 return 1;
13467 }
13468
13469
13470 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13471 PyObject *pyobj;
13472
13473 {
13474 #if wxUSE_UNICODE
13475 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13476 #else
13477 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13478 #endif
13479 }
13480 return pyobj;
13481 }
13482
13483
13484 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13485 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13486 return 1;
13487 }
13488
13489
13490 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13491 PyObject *pyobj;
13492
13493 {
13494 #if wxUSE_UNICODE
13495 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13496 #else
13497 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13498 #endif
13499 }
13500 return pyobj;
13501 }
13502
13503
13504 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13505 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13506 return 1;
13507 }
13508
13509
13510 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13511 PyObject *pyobj;
13512
13513 {
13514 #if wxUSE_UNICODE
13515 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13516 #else
13517 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13518 #endif
13519 }
13520 return pyobj;
13521 }
13522
13523
13524 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13525 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13526 return 1;
13527 }
13528
13529
13530 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13531 PyObject *pyobj;
13532
13533 {
13534 #if wxUSE_UNICODE
13535 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13536 #else
13537 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13538 #endif
13539 }
13540 return pyobj;
13541 }
13542
13543
13544 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13545 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13546 return 1;
13547 }
13548
13549
13550 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13551 PyObject *pyobj;
13552
13553 {
13554 #if wxUSE_UNICODE
13555 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13556 #else
13557 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13558 #endif
13559 }
13560 return pyobj;
13561 }
13562
13563
13564 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13565 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13566 return 1;
13567 }
13568
13569
13570 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13571 PyObject *pyobj;
13572
13573 {
13574 #if wxUSE_UNICODE
13575 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13576 #else
13577 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13578 #endif
13579 }
13580 return pyobj;
13581 }
13582
13583
13584 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13585 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13586 return 1;
13587 }
13588
13589
13590 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13591 PyObject *pyobj;
13592
13593 {
13594 #if wxUSE_UNICODE
13595 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13596 #else
13597 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13598 #endif
13599 }
13600 return pyobj;
13601 }
13602
13603
13604 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13605 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13606 return 1;
13607 }
13608
13609
13610 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13611 PyObject *pyobj;
13612
13613 {
13614 #if wxUSE_UNICODE
13615 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13616 #else
13617 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13618 #endif
13619 }
13620 return pyobj;
13621 }
13622
13623
13624 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13625 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13626 return 1;
13627 }
13628
13629
13630 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13631 PyObject *pyobj;
13632
13633 {
13634 #if wxUSE_UNICODE
13635 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13636 #else
13637 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13638 #endif
13639 }
13640 return pyobj;
13641 }
13642
13643
13644 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13645 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13646 return 1;
13647 }
13648
13649
13650 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13651 PyObject *pyobj;
13652
13653 {
13654 #if wxUSE_UNICODE
13655 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13656 #else
13657 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13658 #endif
13659 }
13660 return pyobj;
13661 }
13662
13663
13664 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13665 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13666 return 1;
13667 }
13668
13669
13670 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13671 PyObject *pyobj;
13672
13673 {
13674 #if wxUSE_UNICODE
13675 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13676 #else
13677 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13678 #endif
13679 }
13680 return pyobj;
13681 }
13682
13683
13684 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 wxBMPHandler *result;
13687 char *kwnames[] = {
13688 NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 result = (wxBMPHandler *)new wxBMPHandler();
13695
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13700 return resultobj;
13701 fail:
13702 return NULL;
13703 }
13704
13705
13706 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13707 PyObject *obj;
13708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13709 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13710 Py_INCREF(obj);
13711 return Py_BuildValue((char *)"");
13712 }
13713 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj;
13715 wxICOHandler *result;
13716 char *kwnames[] = {
13717 NULL
13718 };
13719
13720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (wxICOHandler *)new wxICOHandler();
13724
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13729 return resultobj;
13730 fail:
13731 return NULL;
13732 }
13733
13734
13735 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13736 PyObject *obj;
13737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13738 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13739 Py_INCREF(obj);
13740 return Py_BuildValue((char *)"");
13741 }
13742 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj;
13744 wxCURHandler *result;
13745 char *kwnames[] = {
13746 NULL
13747 };
13748
13749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (wxCURHandler *)new wxCURHandler();
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13758 return resultobj;
13759 fail:
13760 return NULL;
13761 }
13762
13763
13764 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13765 PyObject *obj;
13766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13767 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13768 Py_INCREF(obj);
13769 return Py_BuildValue((char *)"");
13770 }
13771 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj;
13773 wxANIHandler *result;
13774 char *kwnames[] = {
13775 NULL
13776 };
13777
13778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 result = (wxANIHandler *)new wxANIHandler();
13782
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13787 return resultobj;
13788 fail:
13789 return NULL;
13790 }
13791
13792
13793 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13794 PyObject *obj;
13795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13796 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13797 Py_INCREF(obj);
13798 return Py_BuildValue((char *)"");
13799 }
13800 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj;
13802 wxPNGHandler *result;
13803 char *kwnames[] = {
13804 NULL
13805 };
13806
13807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13808 {
13809 PyThreadState* __tstate = wxPyBeginAllowThreads();
13810 result = (wxPNGHandler *)new wxPNGHandler();
13811
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13823 PyObject *obj;
13824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13825 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13826 Py_INCREF(obj);
13827 return Py_BuildValue((char *)"");
13828 }
13829 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj;
13831 wxGIFHandler *result;
13832 char *kwnames[] = {
13833 NULL
13834 };
13835
13836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13837 {
13838 PyThreadState* __tstate = wxPyBeginAllowThreads();
13839 result = (wxGIFHandler *)new wxGIFHandler();
13840
13841 wxPyEndAllowThreads(__tstate);
13842 if (PyErr_Occurred()) SWIG_fail;
13843 }
13844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13845 return resultobj;
13846 fail:
13847 return NULL;
13848 }
13849
13850
13851 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13852 PyObject *obj;
13853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13854 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13855 Py_INCREF(obj);
13856 return Py_BuildValue((char *)"");
13857 }
13858 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxPCXHandler *result;
13861 char *kwnames[] = {
13862 NULL
13863 };
13864
13865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 result = (wxPCXHandler *)new wxPCXHandler();
13869
13870 wxPyEndAllowThreads(__tstate);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 }
13873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13874 return resultobj;
13875 fail:
13876 return NULL;
13877 }
13878
13879
13880 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13881 PyObject *obj;
13882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13883 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13884 Py_INCREF(obj);
13885 return Py_BuildValue((char *)"");
13886 }
13887 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj;
13889 wxJPEGHandler *result;
13890 char *kwnames[] = {
13891 NULL
13892 };
13893
13894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13895 {
13896 PyThreadState* __tstate = wxPyBeginAllowThreads();
13897 result = (wxJPEGHandler *)new wxJPEGHandler();
13898
13899 wxPyEndAllowThreads(__tstate);
13900 if (PyErr_Occurred()) SWIG_fail;
13901 }
13902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13903 return resultobj;
13904 fail:
13905 return NULL;
13906 }
13907
13908
13909 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13910 PyObject *obj;
13911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13912 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13913 Py_INCREF(obj);
13914 return Py_BuildValue((char *)"");
13915 }
13916 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj;
13918 wxPNMHandler *result;
13919 char *kwnames[] = {
13920 NULL
13921 };
13922
13923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (wxPNMHandler *)new wxPNMHandler();
13927
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13939 PyObject *obj;
13940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13941 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13942 Py_INCREF(obj);
13943 return Py_BuildValue((char *)"");
13944 }
13945 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13946 PyObject *resultobj;
13947 wxXPMHandler *result;
13948 char *kwnames[] = {
13949 NULL
13950 };
13951
13952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 result = (wxXPMHandler *)new wxXPMHandler();
13956
13957 wxPyEndAllowThreads(__tstate);
13958 if (PyErr_Occurred()) SWIG_fail;
13959 }
13960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13961 return resultobj;
13962 fail:
13963 return NULL;
13964 }
13965
13966
13967 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13968 PyObject *obj;
13969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13970 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13971 Py_INCREF(obj);
13972 return Py_BuildValue((char *)"");
13973 }
13974 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj;
13976 wxTIFFHandler *result;
13977 char *kwnames[] = {
13978 NULL
13979 };
13980
13981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13982 {
13983 PyThreadState* __tstate = wxPyBeginAllowThreads();
13984 result = (wxTIFFHandler *)new wxTIFFHandler();
13985
13986 wxPyEndAllowThreads(__tstate);
13987 if (PyErr_Occurred()) SWIG_fail;
13988 }
13989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13990 return resultobj;
13991 fail:
13992 return NULL;
13993 }
13994
13995
13996 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13997 PyObject *obj;
13998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13999 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14000 Py_INCREF(obj);
14001 return Py_BuildValue((char *)"");
14002 }
14003 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj;
14005 wxImage *arg1 = 0 ;
14006 wxImage *arg2 = 0 ;
14007 int arg3 = (int) 236 ;
14008 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14009 bool result;
14010 PyObject * obj0 = 0 ;
14011 PyObject * obj1 = 0 ;
14012 PyObject * obj2 = 0 ;
14013 PyObject * obj3 = 0 ;
14014 char *kwnames[] = {
14015 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14016 };
14017
14018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14019 {
14020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14021 if (SWIG_arg_fail(1)) SWIG_fail;
14022 if (arg1 == NULL) {
14023 SWIG_null_ref("wxImage");
14024 }
14025 if (SWIG_arg_fail(1)) SWIG_fail;
14026 }
14027 {
14028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14029 if (SWIG_arg_fail(2)) SWIG_fail;
14030 if (arg2 == NULL) {
14031 SWIG_null_ref("wxImage");
14032 }
14033 if (SWIG_arg_fail(2)) SWIG_fail;
14034 }
14035 if (obj2) {
14036 {
14037 arg3 = (int)(SWIG_As_int(obj2));
14038 if (SWIG_arg_fail(3)) SWIG_fail;
14039 }
14040 }
14041 if (obj3) {
14042 {
14043 arg4 = (int)(SWIG_As_int(obj3));
14044 if (SWIG_arg_fail(4)) SWIG_fail;
14045 }
14046 }
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14050
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 {
14055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14056 }
14057 return resultobj;
14058 fail:
14059 return NULL;
14060 }
14061
14062
14063 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14064 PyObject *obj;
14065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14066 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14067 Py_INCREF(obj);
14068 return Py_BuildValue((char *)"");
14069 }
14070 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj;
14072 wxEvtHandler *result;
14073 char *kwnames[] = {
14074 NULL
14075 };
14076
14077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14078 {
14079 PyThreadState* __tstate = wxPyBeginAllowThreads();
14080 result = (wxEvtHandler *)new wxEvtHandler();
14081
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14086 return resultobj;
14087 fail:
14088 return NULL;
14089 }
14090
14091
14092 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14093 PyObject *resultobj;
14094 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14095 wxEvtHandler *result;
14096 PyObject * obj0 = 0 ;
14097 char *kwnames[] = {
14098 (char *) "self", NULL
14099 };
14100
14101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(1)) SWIG_fail;
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14107
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 {
14112 resultobj = wxPyMake_wxObject(result, 0);
14113 }
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj;
14122 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14123 wxEvtHandler *result;
14124 PyObject * obj0 = 0 ;
14125 char *kwnames[] = {
14126 (char *) "self", NULL
14127 };
14128
14129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14131 if (SWIG_arg_fail(1)) SWIG_fail;
14132 {
14133 PyThreadState* __tstate = wxPyBeginAllowThreads();
14134 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14135
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 {
14140 resultobj = wxPyMake_wxObject(result, 0);
14141 }
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj;
14150 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14151 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "self",(char *) "handler", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14162 if (SWIG_arg_fail(2)) SWIG_fail;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 (arg1)->SetNextHandler(arg2);
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 Py_INCREF(Py_None); resultobj = Py_None;
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14180 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14181 PyObject * obj0 = 0 ;
14182 PyObject * obj1 = 0 ;
14183 char *kwnames[] = {
14184 (char *) "self",(char *) "handler", NULL
14185 };
14186
14187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14189 if (SWIG_arg_fail(1)) SWIG_fail;
14190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14191 if (SWIG_arg_fail(2)) SWIG_fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 (arg1)->SetPreviousHandler(arg2);
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 Py_INCREF(Py_None); resultobj = Py_None;
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj;
14208 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14209 bool result;
14210 PyObject * obj0 = 0 ;
14211 char *kwnames[] = {
14212 (char *) "self", NULL
14213 };
14214
14215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14217 if (SWIG_arg_fail(1)) SWIG_fail;
14218 {
14219 PyThreadState* __tstate = wxPyBeginAllowThreads();
14220 result = (bool)(arg1)->GetEvtHandlerEnabled();
14221
14222 wxPyEndAllowThreads(__tstate);
14223 if (PyErr_Occurred()) SWIG_fail;
14224 }
14225 {
14226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14227 }
14228 return resultobj;
14229 fail:
14230 return NULL;
14231 }
14232
14233
14234 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj;
14236 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14237 bool arg2 ;
14238 PyObject * obj0 = 0 ;
14239 PyObject * obj1 = 0 ;
14240 char *kwnames[] = {
14241 (char *) "self",(char *) "enabled", NULL
14242 };
14243
14244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14246 if (SWIG_arg_fail(1)) SWIG_fail;
14247 {
14248 arg2 = (bool)(SWIG_As_bool(obj1));
14249 if (SWIG_arg_fail(2)) SWIG_fail;
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 (arg1)->SetEvtHandlerEnabled(arg2);
14254
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 Py_INCREF(Py_None); resultobj = Py_None;
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14266 PyObject *resultobj;
14267 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14268 wxEvent *arg2 = 0 ;
14269 bool result;
14270 PyObject * obj0 = 0 ;
14271 PyObject * obj1 = 0 ;
14272 char *kwnames[] = {
14273 (char *) "self",(char *) "event", NULL
14274 };
14275
14276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14278 if (SWIG_arg_fail(1)) SWIG_fail;
14279 {
14280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14281 if (SWIG_arg_fail(2)) SWIG_fail;
14282 if (arg2 == NULL) {
14283 SWIG_null_ref("wxEvent");
14284 }
14285 if (SWIG_arg_fail(2)) SWIG_fail;
14286 }
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (bool)(arg1)->ProcessEvent(*arg2);
14290
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 {
14295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14296 }
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj;
14305 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14306 wxEvent *arg2 = 0 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 char *kwnames[] = {
14310 (char *) "self",(char *) "event", NULL
14311 };
14312
14313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14315 if (SWIG_arg_fail(1)) SWIG_fail;
14316 {
14317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(2)) SWIG_fail;
14319 if (arg2 == NULL) {
14320 SWIG_null_ref("wxEvent");
14321 }
14322 if (SWIG_arg_fail(2)) SWIG_fail;
14323 }
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 (arg1)->AddPendingEvent(*arg2);
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 Py_INCREF(Py_None); resultobj = Py_None;
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14339 PyObject *resultobj;
14340 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14341 PyObject * obj0 = 0 ;
14342 char *kwnames[] = {
14343 (char *) "self", NULL
14344 };
14345
14346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14348 if (SWIG_arg_fail(1)) SWIG_fail;
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 (arg1)->ProcessPendingEvents();
14352
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 Py_INCREF(Py_None); resultobj = Py_None;
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj;
14365 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14366 int arg2 ;
14367 int arg3 ;
14368 int arg4 ;
14369 PyObject *arg5 = (PyObject *) 0 ;
14370 PyObject * obj0 = 0 ;
14371 PyObject * obj1 = 0 ;
14372 PyObject * obj2 = 0 ;
14373 PyObject * obj3 = 0 ;
14374 PyObject * obj4 = 0 ;
14375 char *kwnames[] = {
14376 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14377 };
14378
14379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14381 if (SWIG_arg_fail(1)) SWIG_fail;
14382 {
14383 arg2 = (int)(SWIG_As_int(obj1));
14384 if (SWIG_arg_fail(2)) SWIG_fail;
14385 }
14386 {
14387 arg3 = (int)(SWIG_As_int(obj2));
14388 if (SWIG_arg_fail(3)) SWIG_fail;
14389 }
14390 {
14391 arg4 = (int)(SWIG_As_int(obj3));
14392 if (SWIG_arg_fail(4)) SWIG_fail;
14393 }
14394 arg5 = obj4;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 Py_INCREF(Py_None); resultobj = Py_None;
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj;
14411 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14412 int arg2 ;
14413 int arg3 = (int) -1 ;
14414 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14415 bool result;
14416 PyObject * obj0 = 0 ;
14417 PyObject * obj1 = 0 ;
14418 PyObject * obj2 = 0 ;
14419 PyObject * obj3 = 0 ;
14420 char *kwnames[] = {
14421 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14422 };
14423
14424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 {
14428 arg2 = (int)(SWIG_As_int(obj1));
14429 if (SWIG_arg_fail(2)) SWIG_fail;
14430 }
14431 if (obj2) {
14432 {
14433 arg3 = (int)(SWIG_As_int(obj2));
14434 if (SWIG_arg_fail(3)) SWIG_fail;
14435 }
14436 }
14437 if (obj3) {
14438 {
14439 arg4 = (wxEventType)(SWIG_As_int(obj3));
14440 if (SWIG_arg_fail(4)) SWIG_fail;
14441 }
14442 }
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 {
14451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj;
14461 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14462 PyObject *arg2 = (PyObject *) 0 ;
14463 bool arg3 = (bool) true ;
14464 PyObject * obj0 = 0 ;
14465 PyObject * obj1 = 0 ;
14466 PyObject * obj2 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self",(char *) "_self",(char *) "incref", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 arg2 = obj1;
14475 if (obj2) {
14476 {
14477 arg3 = (bool)(SWIG_As_bool(obj2));
14478 if (SWIG_arg_fail(3)) SWIG_fail;
14479 }
14480 }
14481 {
14482 PyThreadState* __tstate = wxPyBeginAllowThreads();
14483 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14484
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 Py_INCREF(Py_None); resultobj = Py_None;
14489 return resultobj;
14490 fail:
14491 return NULL;
14492 }
14493
14494
14495 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14496 PyObject *obj;
14497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14498 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14499 Py_INCREF(obj);
14500 return Py_BuildValue((char *)"");
14501 }
14502 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj;
14504 wxEventType result;
14505 char *kwnames[] = {
14506 NULL
14507 };
14508
14509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14510 {
14511 PyThreadState* __tstate = wxPyBeginAllowThreads();
14512 result = (wxEventType)wxNewEventType();
14513
14514 wxPyEndAllowThreads(__tstate);
14515 if (PyErr_Occurred()) SWIG_fail;
14516 }
14517 {
14518 resultobj = SWIG_From_int((int)(result));
14519 }
14520 return resultobj;
14521 fail:
14522 return NULL;
14523 }
14524
14525
14526 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14527 PyObject *resultobj;
14528 wxEvent *arg1 = (wxEvent *) 0 ;
14529 PyObject * obj0 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 delete arg1;
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 Py_INCREF(Py_None); resultobj = Py_None;
14545 return resultobj;
14546 fail:
14547 return NULL;
14548 }
14549
14550
14551 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14552 PyObject *resultobj;
14553 wxEvent *arg1 = (wxEvent *) 0 ;
14554 wxEventType arg2 ;
14555 PyObject * obj0 = 0 ;
14556 PyObject * obj1 = 0 ;
14557 char *kwnames[] = {
14558 (char *) "self",(char *) "typ", NULL
14559 };
14560
14561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14563 if (SWIG_arg_fail(1)) SWIG_fail;
14564 {
14565 arg2 = (wxEventType)(SWIG_As_int(obj1));
14566 if (SWIG_arg_fail(2)) SWIG_fail;
14567 }
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 (arg1)->SetEventType(arg2);
14571
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 Py_INCREF(Py_None); resultobj = Py_None;
14576 return resultobj;
14577 fail:
14578 return NULL;
14579 }
14580
14581
14582 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj;
14584 wxEvent *arg1 = (wxEvent *) 0 ;
14585 wxEventType result;
14586 PyObject * obj0 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14597
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 {
14602 resultobj = SWIG_From_int((int)(result));
14603 }
14604 return resultobj;
14605 fail:
14606 return NULL;
14607 }
14608
14609
14610 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14611 PyObject *resultobj;
14612 wxEvent *arg1 = (wxEvent *) 0 ;
14613 wxObject *result;
14614 PyObject * obj0 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 PyThreadState* __tstate = wxPyBeginAllowThreads();
14624 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14625
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 {
14630 resultobj = wxPyMake_wxObject(result, 0);
14631 }
14632 return resultobj;
14633 fail:
14634 return NULL;
14635 }
14636
14637
14638 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14639 PyObject *resultobj;
14640 wxEvent *arg1 = (wxEvent *) 0 ;
14641 wxObject *arg2 = (wxObject *) 0 ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 char *kwnames[] = {
14645 (char *) "self",(char *) "obj", NULL
14646 };
14647
14648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14650 if (SWIG_arg_fail(1)) SWIG_fail;
14651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14652 if (SWIG_arg_fail(2)) SWIG_fail;
14653 {
14654 PyThreadState* __tstate = wxPyBeginAllowThreads();
14655 (arg1)->SetEventObject(arg2);
14656
14657 wxPyEndAllowThreads(__tstate);
14658 if (PyErr_Occurred()) SWIG_fail;
14659 }
14660 Py_INCREF(Py_None); resultobj = Py_None;
14661 return resultobj;
14662 fail:
14663 return NULL;
14664 }
14665
14666
14667 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14668 PyObject *resultobj;
14669 wxEvent *arg1 = (wxEvent *) 0 ;
14670 long result;
14671 PyObject * obj0 = 0 ;
14672 char *kwnames[] = {
14673 (char *) "self", NULL
14674 };
14675
14676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14678 if (SWIG_arg_fail(1)) SWIG_fail;
14679 {
14680 PyThreadState* __tstate = wxPyBeginAllowThreads();
14681 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14682
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 {
14687 resultobj = SWIG_From_long((long)(result));
14688 }
14689 return resultobj;
14690 fail:
14691 return NULL;
14692 }
14693
14694
14695 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14696 PyObject *resultobj;
14697 wxEvent *arg1 = (wxEvent *) 0 ;
14698 long arg2 = (long) 0 ;
14699 PyObject * obj0 = 0 ;
14700 PyObject * obj1 = 0 ;
14701 char *kwnames[] = {
14702 (char *) "self",(char *) "ts", NULL
14703 };
14704
14705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14707 if (SWIG_arg_fail(1)) SWIG_fail;
14708 if (obj1) {
14709 {
14710 arg2 = (long)(SWIG_As_long(obj1));
14711 if (SWIG_arg_fail(2)) SWIG_fail;
14712 }
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetTimestamp(arg2);
14717
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 Py_INCREF(Py_None); resultobj = Py_None;
14722 return resultobj;
14723 fail:
14724 return NULL;
14725 }
14726
14727
14728 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14729 PyObject *resultobj;
14730 wxEvent *arg1 = (wxEvent *) 0 ;
14731 int result;
14732 PyObject * obj0 = 0 ;
14733 char *kwnames[] = {
14734 (char *) "self", NULL
14735 };
14736
14737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14739 if (SWIG_arg_fail(1)) SWIG_fail;
14740 {
14741 PyThreadState* __tstate = wxPyBeginAllowThreads();
14742 result = (int)((wxEvent const *)arg1)->GetId();
14743
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 {
14748 resultobj = SWIG_From_int((int)(result));
14749 }
14750 return resultobj;
14751 fail:
14752 return NULL;
14753 }
14754
14755
14756 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj;
14758 wxEvent *arg1 = (wxEvent *) 0 ;
14759 int arg2 ;
14760 PyObject * obj0 = 0 ;
14761 PyObject * obj1 = 0 ;
14762 char *kwnames[] = {
14763 (char *) "self",(char *) "Id", NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14768 if (SWIG_arg_fail(1)) SWIG_fail;
14769 {
14770 arg2 = (int)(SWIG_As_int(obj1));
14771 if (SWIG_arg_fail(2)) SWIG_fail;
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 (arg1)->SetId(arg2);
14776
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 Py_INCREF(Py_None); resultobj = Py_None;
14781 return resultobj;
14782 fail:
14783 return NULL;
14784 }
14785
14786
14787 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14788 PyObject *resultobj;
14789 wxEvent *arg1 = (wxEvent *) 0 ;
14790 bool result;
14791 PyObject * obj0 = 0 ;
14792 char *kwnames[] = {
14793 (char *) "self", NULL
14794 };
14795
14796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14798 if (SWIG_arg_fail(1)) SWIG_fail;
14799 {
14800 PyThreadState* __tstate = wxPyBeginAllowThreads();
14801 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14802
14803 wxPyEndAllowThreads(__tstate);
14804 if (PyErr_Occurred()) SWIG_fail;
14805 }
14806 {
14807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14808 }
14809 return resultobj;
14810 fail:
14811 return NULL;
14812 }
14813
14814
14815 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14816 PyObject *resultobj;
14817 wxEvent *arg1 = (wxEvent *) 0 ;
14818 bool arg2 = (bool) true ;
14819 PyObject * obj0 = 0 ;
14820 PyObject * obj1 = 0 ;
14821 char *kwnames[] = {
14822 (char *) "self",(char *) "skip", NULL
14823 };
14824
14825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14827 if (SWIG_arg_fail(1)) SWIG_fail;
14828 if (obj1) {
14829 {
14830 arg2 = (bool)(SWIG_As_bool(obj1));
14831 if (SWIG_arg_fail(2)) SWIG_fail;
14832 }
14833 }
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 (arg1)->Skip(arg2);
14837
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 Py_INCREF(Py_None); resultobj = Py_None;
14842 return resultobj;
14843 fail:
14844 return NULL;
14845 }
14846
14847
14848 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14849 PyObject *resultobj;
14850 wxEvent *arg1 = (wxEvent *) 0 ;
14851 bool result;
14852 PyObject * obj0 = 0 ;
14853 char *kwnames[] = {
14854 (char *) "self", NULL
14855 };
14856
14857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14859 if (SWIG_arg_fail(1)) SWIG_fail;
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14863
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 {
14868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14869 }
14870 return resultobj;
14871 fail:
14872 return NULL;
14873 }
14874
14875
14876 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj;
14878 wxEvent *arg1 = (wxEvent *) 0 ;
14879 bool result;
14880 PyObject * obj0 = 0 ;
14881 char *kwnames[] = {
14882 (char *) "self", NULL
14883 };
14884
14885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14887 if (SWIG_arg_fail(1)) SWIG_fail;
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14891
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 {
14896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14897 }
14898 return resultobj;
14899 fail:
14900 return NULL;
14901 }
14902
14903
14904 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14905 PyObject *resultobj;
14906 wxEvent *arg1 = (wxEvent *) 0 ;
14907 int result;
14908 PyObject * obj0 = 0 ;
14909 char *kwnames[] = {
14910 (char *) "self", NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14915 if (SWIG_arg_fail(1)) SWIG_fail;
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (int)(arg1)->StopPropagation();
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 {
14924 resultobj = SWIG_From_int((int)(result));
14925 }
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj;
14934 wxEvent *arg1 = (wxEvent *) 0 ;
14935 int arg2 ;
14936 PyObject * obj0 = 0 ;
14937 PyObject * obj1 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self",(char *) "propagationLevel", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 arg2 = (int)(SWIG_As_int(obj1));
14947 if (SWIG_arg_fail(2)) SWIG_fail;
14948 }
14949 {
14950 PyThreadState* __tstate = wxPyBeginAllowThreads();
14951 (arg1)->ResumePropagation(arg2);
14952
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 Py_INCREF(Py_None); resultobj = Py_None;
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14964 PyObject *resultobj;
14965 wxEvent *arg1 = (wxEvent *) 0 ;
14966 wxEvent *result;
14967 PyObject * obj0 = 0 ;
14968 char *kwnames[] = {
14969 (char *) "self", NULL
14970 };
14971
14972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14974 if (SWIG_arg_fail(1)) SWIG_fail;
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (wxEvent *)(arg1)->Clone();
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14990 PyObject *obj;
14991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14992 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14993 Py_INCREF(obj);
14994 return Py_BuildValue((char *)"");
14995 }
14996 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj;
14998 wxEvent *arg1 = 0 ;
14999 wxPropagationDisabler *result;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "event", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15006 {
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 if (arg1 == NULL) {
15010 SWIG_null_ref("wxEvent");
15011 }
15012 if (SWIG_arg_fail(1)) SWIG_fail;
15013 }
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15017
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj;
15030 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15031 PyObject * obj0 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 delete arg1;
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 Py_INCREF(Py_None); resultobj = Py_None;
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15054 PyObject *obj;
15055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15056 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15057 Py_INCREF(obj);
15058 return Py_BuildValue((char *)"");
15059 }
15060 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15061 PyObject *resultobj;
15062 wxEvent *arg1 = 0 ;
15063 wxPropagateOnce *result;
15064 PyObject * obj0 = 0 ;
15065 char *kwnames[] = {
15066 (char *) "event", NULL
15067 };
15068
15069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15070 {
15071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15072 if (SWIG_arg_fail(1)) SWIG_fail;
15073 if (arg1 == NULL) {
15074 SWIG_null_ref("wxEvent");
15075 }
15076 if (SWIG_arg_fail(1)) SWIG_fail;
15077 }
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15081
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15093 PyObject *resultobj;
15094 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15095 PyObject * obj0 = 0 ;
15096 char *kwnames[] = {
15097 (char *) "self", NULL
15098 };
15099
15100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15102 if (SWIG_arg_fail(1)) SWIG_fail;
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 delete arg1;
15106
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 Py_INCREF(Py_None); resultobj = Py_None;
15111 return resultobj;
15112 fail:
15113 return NULL;
15114 }
15115
15116
15117 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15118 PyObject *obj;
15119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15120 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15121 Py_INCREF(obj);
15122 return Py_BuildValue((char *)"");
15123 }
15124 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj;
15126 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15127 int arg2 = (int) 0 ;
15128 wxCommandEvent *result;
15129 PyObject * obj0 = 0 ;
15130 PyObject * obj1 = 0 ;
15131 char *kwnames[] = {
15132 (char *) "commandType",(char *) "winid", NULL
15133 };
15134
15135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15136 if (obj0) {
15137 {
15138 arg1 = (wxEventType)(SWIG_As_int(obj0));
15139 if (SWIG_arg_fail(1)) SWIG_fail;
15140 }
15141 }
15142 if (obj1) {
15143 {
15144 arg2 = (int)(SWIG_As_int(obj1));
15145 if (SWIG_arg_fail(2)) SWIG_fail;
15146 }
15147 }
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15151
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15163 PyObject *resultobj;
15164 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15165 int result;
15166 PyObject * obj0 = 0 ;
15167 char *kwnames[] = {
15168 (char *) "self", NULL
15169 };
15170
15171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15173 if (SWIG_arg_fail(1)) SWIG_fail;
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15177
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 {
15182 resultobj = SWIG_From_int((int)(result));
15183 }
15184 return resultobj;
15185 fail:
15186 return NULL;
15187 }
15188
15189
15190 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj;
15192 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15193 wxString *arg2 = 0 ;
15194 bool temp2 = false ;
15195 PyObject * obj0 = 0 ;
15196 PyObject * obj1 = 0 ;
15197 char *kwnames[] = {
15198 (char *) "self",(char *) "s", NULL
15199 };
15200
15201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15203 if (SWIG_arg_fail(1)) SWIG_fail;
15204 {
15205 arg2 = wxString_in_helper(obj1);
15206 if (arg2 == NULL) SWIG_fail;
15207 temp2 = true;
15208 }
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 (arg1)->SetString((wxString const &)*arg2);
15212
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 Py_INCREF(Py_None); resultobj = Py_None;
15217 {
15218 if (temp2)
15219 delete arg2;
15220 }
15221 return resultobj;
15222 fail:
15223 {
15224 if (temp2)
15225 delete arg2;
15226 }
15227 return NULL;
15228 }
15229
15230
15231 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj;
15233 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15234 wxString result;
15235 PyObject * obj0 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "self", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 {
15244 PyThreadState* __tstate = wxPyBeginAllowThreads();
15245 result = ((wxCommandEvent const *)arg1)->GetString();
15246
15247 wxPyEndAllowThreads(__tstate);
15248 if (PyErr_Occurred()) SWIG_fail;
15249 }
15250 {
15251 #if wxUSE_UNICODE
15252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15253 #else
15254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15255 #endif
15256 }
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15264 PyObject *resultobj;
15265 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15266 bool result;
15267 PyObject * obj0 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self", NULL
15270 };
15271
15272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15274 if (SWIG_arg_fail(1)) SWIG_fail;
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15278
15279 wxPyEndAllowThreads(__tstate);
15280 if (PyErr_Occurred()) SWIG_fail;
15281 }
15282 {
15283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15284 }
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj;
15293 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15294 bool result;
15295 PyObject * obj0 = 0 ;
15296 char *kwnames[] = {
15297 (char *) "self", NULL
15298 };
15299
15300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15302 if (SWIG_arg_fail(1)) SWIG_fail;
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15306
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 {
15311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15312 }
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15322 long arg2 ;
15323 PyObject * obj0 = 0 ;
15324 PyObject * obj1 = 0 ;
15325 char *kwnames[] = {
15326 (char *) "self",(char *) "extraLong", NULL
15327 };
15328
15329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15331 if (SWIG_arg_fail(1)) SWIG_fail;
15332 {
15333 arg2 = (long)(SWIG_As_long(obj1));
15334 if (SWIG_arg_fail(2)) SWIG_fail;
15335 }
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 (arg1)->SetExtraLong(arg2);
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 Py_INCREF(Py_None); resultobj = Py_None;
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15351 PyObject *resultobj;
15352 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15353 long result;
15354 PyObject * obj0 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15365
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 {
15370 resultobj = SWIG_From_long((long)(result));
15371 }
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15379 PyObject *resultobj;
15380 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15381 int arg2 ;
15382 PyObject * obj0 = 0 ;
15383 PyObject * obj1 = 0 ;
15384 char *kwnames[] = {
15385 (char *) "self",(char *) "i", NULL
15386 };
15387
15388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15390 if (SWIG_arg_fail(1)) SWIG_fail;
15391 {
15392 arg2 = (int)(SWIG_As_int(obj1));
15393 if (SWIG_arg_fail(2)) SWIG_fail;
15394 }
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 (arg1)->SetInt(arg2);
15398
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 Py_INCREF(Py_None); resultobj = Py_None;
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj;
15411 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15412 long result;
15413 PyObject * obj0 = 0 ;
15414 char *kwnames[] = {
15415 (char *) "self", NULL
15416 };
15417
15418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15420 if (SWIG_arg_fail(1)) SWIG_fail;
15421 {
15422 PyThreadState* __tstate = wxPyBeginAllowThreads();
15423 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15424
15425 wxPyEndAllowThreads(__tstate);
15426 if (PyErr_Occurred()) SWIG_fail;
15427 }
15428 {
15429 resultobj = SWIG_From_long((long)(result));
15430 }
15431 return resultobj;
15432 fail:
15433 return NULL;
15434 }
15435
15436
15437 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15438 PyObject *resultobj;
15439 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15440 wxEvent *result;
15441 PyObject * obj0 = 0 ;
15442 char *kwnames[] = {
15443 (char *) "self", NULL
15444 };
15445
15446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15448 if (SWIG_arg_fail(1)) SWIG_fail;
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15452
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15457 return resultobj;
15458 fail:
15459 return NULL;
15460 }
15461
15462
15463 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15464 PyObject *obj;
15465 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15466 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15467 Py_INCREF(obj);
15468 return Py_BuildValue((char *)"");
15469 }
15470 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj;
15472 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15473 int arg2 = (int) 0 ;
15474 wxNotifyEvent *result;
15475 PyObject * obj0 = 0 ;
15476 PyObject * obj1 = 0 ;
15477 char *kwnames[] = {
15478 (char *) "commandType",(char *) "winid", NULL
15479 };
15480
15481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15482 if (obj0) {
15483 {
15484 arg1 = (wxEventType)(SWIG_As_int(obj0));
15485 if (SWIG_arg_fail(1)) SWIG_fail;
15486 }
15487 }
15488 if (obj1) {
15489 {
15490 arg2 = (int)(SWIG_As_int(obj1));
15491 if (SWIG_arg_fail(2)) SWIG_fail;
15492 }
15493 }
15494 {
15495 PyThreadState* __tstate = wxPyBeginAllowThreads();
15496 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15497
15498 wxPyEndAllowThreads(__tstate);
15499 if (PyErr_Occurred()) SWIG_fail;
15500 }
15501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15509 PyObject *resultobj;
15510 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15511 PyObject * obj0 = 0 ;
15512 char *kwnames[] = {
15513 (char *) "self", NULL
15514 };
15515
15516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15518 if (SWIG_arg_fail(1)) SWIG_fail;
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 (arg1)->Veto();
15522
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 Py_INCREF(Py_None); resultobj = Py_None;
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj;
15535 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15536 PyObject * obj0 = 0 ;
15537 char *kwnames[] = {
15538 (char *) "self", NULL
15539 };
15540
15541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 {
15545 PyThreadState* __tstate = wxPyBeginAllowThreads();
15546 (arg1)->Allow();
15547
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 Py_INCREF(Py_None); resultobj = Py_None;
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15559 PyObject *resultobj;
15560 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15561 bool result;
15562 PyObject * obj0 = 0 ;
15563 char *kwnames[] = {
15564 (char *) "self", NULL
15565 };
15566
15567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15569 if (SWIG_arg_fail(1)) SWIG_fail;
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 result = (bool)(arg1)->IsAllowed();
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 {
15578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15579 }
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15587 PyObject *obj;
15588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15589 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15590 Py_INCREF(obj);
15591 return Py_BuildValue((char *)"");
15592 }
15593 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15594 PyObject *resultobj;
15595 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15596 int arg2 = (int) 0 ;
15597 int arg3 = (int) 0 ;
15598 int arg4 = (int) 0 ;
15599 wxScrollEvent *result;
15600 PyObject * obj0 = 0 ;
15601 PyObject * obj1 = 0 ;
15602 PyObject * obj2 = 0 ;
15603 PyObject * obj3 = 0 ;
15604 char *kwnames[] = {
15605 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15606 };
15607
15608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15609 if (obj0) {
15610 {
15611 arg1 = (wxEventType)(SWIG_As_int(obj0));
15612 if (SWIG_arg_fail(1)) SWIG_fail;
15613 }
15614 }
15615 if (obj1) {
15616 {
15617 arg2 = (int)(SWIG_As_int(obj1));
15618 if (SWIG_arg_fail(2)) SWIG_fail;
15619 }
15620 }
15621 if (obj2) {
15622 {
15623 arg3 = (int)(SWIG_As_int(obj2));
15624 if (SWIG_arg_fail(3)) SWIG_fail;
15625 }
15626 }
15627 if (obj3) {
15628 {
15629 arg4 = (int)(SWIG_As_int(obj3));
15630 if (SWIG_arg_fail(4)) SWIG_fail;
15631 }
15632 }
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15636
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15648 PyObject *resultobj;
15649 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15650 int result;
15651 PyObject * obj0 = 0 ;
15652 char *kwnames[] = {
15653 (char *) "self", NULL
15654 };
15655
15656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15658 if (SWIG_arg_fail(1)) SWIG_fail;
15659 {
15660 PyThreadState* __tstate = wxPyBeginAllowThreads();
15661 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15662
15663 wxPyEndAllowThreads(__tstate);
15664 if (PyErr_Occurred()) SWIG_fail;
15665 }
15666 {
15667 resultobj = SWIG_From_int((int)(result));
15668 }
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15676 PyObject *resultobj;
15677 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15678 int result;
15679 PyObject * obj0 = 0 ;
15680 char *kwnames[] = {
15681 (char *) "self", NULL
15682 };
15683
15684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15686 if (SWIG_arg_fail(1)) SWIG_fail;
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15690
15691 wxPyEndAllowThreads(__tstate);
15692 if (PyErr_Occurred()) SWIG_fail;
15693 }
15694 {
15695 resultobj = SWIG_From_int((int)(result));
15696 }
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj;
15705 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15706 int arg2 ;
15707 PyObject * obj0 = 0 ;
15708 PyObject * obj1 = 0 ;
15709 char *kwnames[] = {
15710 (char *) "self",(char *) "orient", NULL
15711 };
15712
15713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15715 if (SWIG_arg_fail(1)) SWIG_fail;
15716 {
15717 arg2 = (int)(SWIG_As_int(obj1));
15718 if (SWIG_arg_fail(2)) SWIG_fail;
15719 }
15720 {
15721 PyThreadState* __tstate = wxPyBeginAllowThreads();
15722 (arg1)->SetOrientation(arg2);
15723
15724 wxPyEndAllowThreads(__tstate);
15725 if (PyErr_Occurred()) SWIG_fail;
15726 }
15727 Py_INCREF(Py_None); resultobj = Py_None;
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15737 int arg2 ;
15738 PyObject * obj0 = 0 ;
15739 PyObject * obj1 = 0 ;
15740 char *kwnames[] = {
15741 (char *) "self",(char *) "pos", NULL
15742 };
15743
15744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15746 if (SWIG_arg_fail(1)) SWIG_fail;
15747 {
15748 arg2 = (int)(SWIG_As_int(obj1));
15749 if (SWIG_arg_fail(2)) SWIG_fail;
15750 }
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 (arg1)->SetPosition(arg2);
15754
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 Py_INCREF(Py_None); resultobj = Py_None;
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15766 PyObject *obj;
15767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15768 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15769 Py_INCREF(obj);
15770 return Py_BuildValue((char *)"");
15771 }
15772 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15773 PyObject *resultobj;
15774 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15775 int arg2 = (int) 0 ;
15776 int arg3 = (int) 0 ;
15777 wxScrollWinEvent *result;
15778 PyObject * obj0 = 0 ;
15779 PyObject * obj1 = 0 ;
15780 PyObject * obj2 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15786 if (obj0) {
15787 {
15788 arg1 = (wxEventType)(SWIG_As_int(obj0));
15789 if (SWIG_arg_fail(1)) SWIG_fail;
15790 }
15791 }
15792 if (obj1) {
15793 {
15794 arg2 = (int)(SWIG_As_int(obj1));
15795 if (SWIG_arg_fail(2)) SWIG_fail;
15796 }
15797 }
15798 if (obj2) {
15799 {
15800 arg3 = (int)(SWIG_As_int(obj2));
15801 if (SWIG_arg_fail(3)) SWIG_fail;
15802 }
15803 }
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15807
15808 wxPyEndAllowThreads(__tstate);
15809 if (PyErr_Occurred()) SWIG_fail;
15810 }
15811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15812 return resultobj;
15813 fail:
15814 return NULL;
15815 }
15816
15817
15818 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15819 PyObject *resultobj;
15820 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15821 int result;
15822 PyObject * obj0 = 0 ;
15823 char *kwnames[] = {
15824 (char *) "self", NULL
15825 };
15826
15827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15829 if (SWIG_arg_fail(1)) SWIG_fail;
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15833
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 {
15838 resultobj = SWIG_From_int((int)(result));
15839 }
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj;
15848 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15849 int result;
15850 PyObject * obj0 = 0 ;
15851 char *kwnames[] = {
15852 (char *) "self", NULL
15853 };
15854
15855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15857 if (SWIG_arg_fail(1)) SWIG_fail;
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15861
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 {
15866 resultobj = SWIG_From_int((int)(result));
15867 }
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj;
15876 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15877 int arg2 ;
15878 PyObject * obj0 = 0 ;
15879 PyObject * obj1 = 0 ;
15880 char *kwnames[] = {
15881 (char *) "self",(char *) "orient", NULL
15882 };
15883
15884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15886 if (SWIG_arg_fail(1)) SWIG_fail;
15887 {
15888 arg2 = (int)(SWIG_As_int(obj1));
15889 if (SWIG_arg_fail(2)) SWIG_fail;
15890 }
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 (arg1)->SetOrientation(arg2);
15894
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 Py_INCREF(Py_None); resultobj = Py_None;
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj;
15907 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15908 int arg2 ;
15909 PyObject * obj0 = 0 ;
15910 PyObject * obj1 = 0 ;
15911 char *kwnames[] = {
15912 (char *) "self",(char *) "pos", NULL
15913 };
15914
15915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15917 if (SWIG_arg_fail(1)) SWIG_fail;
15918 {
15919 arg2 = (int)(SWIG_As_int(obj1));
15920 if (SWIG_arg_fail(2)) SWIG_fail;
15921 }
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 (arg1)->SetPosition(arg2);
15925
15926 wxPyEndAllowThreads(__tstate);
15927 if (PyErr_Occurred()) SWIG_fail;
15928 }
15929 Py_INCREF(Py_None); resultobj = Py_None;
15930 return resultobj;
15931 fail:
15932 return NULL;
15933 }
15934
15935
15936 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15937 PyObject *obj;
15938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15939 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15940 Py_INCREF(obj);
15941 return Py_BuildValue((char *)"");
15942 }
15943 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15944 PyObject *resultobj;
15945 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15946 wxMouseEvent *result;
15947 PyObject * obj0 = 0 ;
15948 char *kwnames[] = {
15949 (char *) "mouseType", NULL
15950 };
15951
15952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15953 if (obj0) {
15954 {
15955 arg1 = (wxEventType)(SWIG_As_int(obj0));
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 }
15958 }
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 resultobj = wxPyMake_wxObject(result, 1);
15968 }
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj;
15977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15978 bool result;
15979 PyObject * obj0 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 PyThreadState* __tstate = wxPyBeginAllowThreads();
15989 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15990
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 {
15995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15996 }
15997 return resultobj;
15998 fail:
15999 return NULL;
16000 }
16001
16002
16003 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16004 PyObject *resultobj;
16005 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16006 int arg2 = (int) wxMOUSE_BTN_ANY ;
16007 bool result;
16008 PyObject * obj0 = 0 ;
16009 PyObject * obj1 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self",(char *) "but", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 if (obj1) {
16018 {
16019 arg2 = (int)(SWIG_As_int(obj1));
16020 if (SWIG_arg_fail(2)) SWIG_fail;
16021 }
16022 }
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16026
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 {
16031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16032 }
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj;
16041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16042 int arg2 = (int) wxMOUSE_BTN_ANY ;
16043 bool result;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 char *kwnames[] = {
16047 (char *) "self",(char *) "but", NULL
16048 };
16049
16050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16052 if (SWIG_arg_fail(1)) SWIG_fail;
16053 if (obj1) {
16054 {
16055 arg2 = (int)(SWIG_As_int(obj1));
16056 if (SWIG_arg_fail(2)) SWIG_fail;
16057 }
16058 }
16059 {
16060 PyThreadState* __tstate = wxPyBeginAllowThreads();
16061 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16062
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 {
16067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16068 }
16069 return resultobj;
16070 fail:
16071 return NULL;
16072 }
16073
16074
16075 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16076 PyObject *resultobj;
16077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16078 int arg2 = (int) wxMOUSE_BTN_ANY ;
16079 bool result;
16080 PyObject * obj0 = 0 ;
16081 PyObject * obj1 = 0 ;
16082 char *kwnames[] = {
16083 (char *) "self",(char *) "but", NULL
16084 };
16085
16086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16088 if (SWIG_arg_fail(1)) SWIG_fail;
16089 if (obj1) {
16090 {
16091 arg2 = (int)(SWIG_As_int(obj1));
16092 if (SWIG_arg_fail(2)) SWIG_fail;
16093 }
16094 }
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16098
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 {
16103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16104 }
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj;
16113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16114 int arg2 ;
16115 bool result;
16116 PyObject * obj0 = 0 ;
16117 PyObject * obj1 = 0 ;
16118 char *kwnames[] = {
16119 (char *) "self",(char *) "but", NULL
16120 };
16121
16122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16124 if (SWIG_arg_fail(1)) SWIG_fail;
16125 {
16126 arg2 = (int)(SWIG_As_int(obj1));
16127 if (SWIG_arg_fail(2)) SWIG_fail;
16128 }
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16132
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 {
16137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16138 }
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16148 int arg2 ;
16149 bool result;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 char *kwnames[] = {
16153 (char *) "self",(char *) "but", NULL
16154 };
16155
16156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16158 if (SWIG_arg_fail(1)) SWIG_fail;
16159 {
16160 arg2 = (int)(SWIG_As_int(obj1));
16161 if (SWIG_arg_fail(2)) SWIG_fail;
16162 }
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16166
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 {
16171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16172 }
16173 return resultobj;
16174 fail:
16175 return NULL;
16176 }
16177
16178
16179 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16180 PyObject *resultobj;
16181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16182 int result;
16183 PyObject * obj0 = 0 ;
16184 char *kwnames[] = {
16185 (char *) "self", NULL
16186 };
16187
16188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16190 if (SWIG_arg_fail(1)) SWIG_fail;
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16194
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 {
16199 resultobj = SWIG_From_int((int)(result));
16200 }
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj;
16209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16210 bool result;
16211 PyObject * obj0 = 0 ;
16212 char *kwnames[] = {
16213 (char *) "self", NULL
16214 };
16215
16216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16218 if (SWIG_arg_fail(1)) SWIG_fail;
16219 {
16220 PyThreadState* __tstate = wxPyBeginAllowThreads();
16221 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16222
16223 wxPyEndAllowThreads(__tstate);
16224 if (PyErr_Occurred()) SWIG_fail;
16225 }
16226 {
16227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16228 }
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj;
16237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16238 bool result;
16239 PyObject * obj0 = 0 ;
16240 char *kwnames[] = {
16241 (char *) "self", NULL
16242 };
16243
16244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16246 if (SWIG_arg_fail(1)) SWIG_fail;
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 {
16255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16256 }
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16264 PyObject *resultobj;
16265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16266 bool result;
16267 PyObject * obj0 = 0 ;
16268 char *kwnames[] = {
16269 (char *) "self", NULL
16270 };
16271
16272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16274 if (SWIG_arg_fail(1)) SWIG_fail;
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16278
16279 wxPyEndAllowThreads(__tstate);
16280 if (PyErr_Occurred()) SWIG_fail;
16281 }
16282 {
16283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16284 }
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj;
16293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16294 bool result;
16295 PyObject * obj0 = 0 ;
16296 char *kwnames[] = {
16297 (char *) "self", NULL
16298 };
16299
16300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16302 if (SWIG_arg_fail(1)) SWIG_fail;
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16306
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16312 }
16313 return resultobj;
16314 fail:
16315 return NULL;
16316 }
16317
16318
16319 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16320 PyObject *resultobj;
16321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16322 bool result;
16323 PyObject * obj0 = 0 ;
16324 char *kwnames[] = {
16325 (char *) "self", NULL
16326 };
16327
16328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16330 if (SWIG_arg_fail(1)) SWIG_fail;
16331 {
16332 PyThreadState* __tstate = wxPyBeginAllowThreads();
16333 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16334
16335 wxPyEndAllowThreads(__tstate);
16336 if (PyErr_Occurred()) SWIG_fail;
16337 }
16338 {
16339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16340 }
16341 return resultobj;
16342 fail:
16343 return NULL;
16344 }
16345
16346
16347 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16348 PyObject *resultobj;
16349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16350 bool result;
16351 PyObject * obj0 = 0 ;
16352 char *kwnames[] = {
16353 (char *) "self", NULL
16354 };
16355
16356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16358 if (SWIG_arg_fail(1)) SWIG_fail;
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16362
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 {
16367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16368 }
16369 return resultobj;
16370 fail:
16371 return NULL;
16372 }
16373
16374
16375 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16376 PyObject *resultobj;
16377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16378 bool result;
16379 PyObject * obj0 = 0 ;
16380 char *kwnames[] = {
16381 (char *) "self", NULL
16382 };
16383
16384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16386 if (SWIG_arg_fail(1)) SWIG_fail;
16387 {
16388 PyThreadState* __tstate = wxPyBeginAllowThreads();
16389 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16390
16391 wxPyEndAllowThreads(__tstate);
16392 if (PyErr_Occurred()) SWIG_fail;
16393 }
16394 {
16395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16396 }
16397 return resultobj;
16398 fail:
16399 return NULL;
16400 }
16401
16402
16403 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16404 PyObject *resultobj;
16405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16406 bool result;
16407 PyObject * obj0 = 0 ;
16408 char *kwnames[] = {
16409 (char *) "self", NULL
16410 };
16411
16412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16414 if (SWIG_arg_fail(1)) SWIG_fail;
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16418
16419 wxPyEndAllowThreads(__tstate);
16420 if (PyErr_Occurred()) SWIG_fail;
16421 }
16422 {
16423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16424 }
16425 return resultobj;
16426 fail:
16427 return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj;
16433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16434 bool result;
16435 PyObject * obj0 = 0 ;
16436 char *kwnames[] = {
16437 (char *) "self", NULL
16438 };
16439
16440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16442 if (SWIG_arg_fail(1)) SWIG_fail;
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16446
16447 wxPyEndAllowThreads(__tstate);
16448 if (PyErr_Occurred()) SWIG_fail;
16449 }
16450 {
16451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16452 }
16453 return resultobj;
16454 fail:
16455 return NULL;
16456 }
16457
16458
16459 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16460 PyObject *resultobj;
16461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16462 bool result;
16463 PyObject * obj0 = 0 ;
16464 char *kwnames[] = {
16465 (char *) "self", NULL
16466 };
16467
16468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16470 if (SWIG_arg_fail(1)) SWIG_fail;
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16474
16475 wxPyEndAllowThreads(__tstate);
16476 if (PyErr_Occurred()) SWIG_fail;
16477 }
16478 {
16479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16480 }
16481 return resultobj;
16482 fail:
16483 return NULL;
16484 }
16485
16486
16487 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16488 PyObject *resultobj;
16489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16490 bool result;
16491 PyObject * obj0 = 0 ;
16492 char *kwnames[] = {
16493 (char *) "self", NULL
16494 };
16495
16496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16498 if (SWIG_arg_fail(1)) SWIG_fail;
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16502
16503 wxPyEndAllowThreads(__tstate);
16504 if (PyErr_Occurred()) SWIG_fail;
16505 }
16506 {
16507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16508 }
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj;
16517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16518 bool result;
16519 PyObject * obj0 = 0 ;
16520 char *kwnames[] = {
16521 (char *) "self", NULL
16522 };
16523
16524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16526 if (SWIG_arg_fail(1)) SWIG_fail;
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16530
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 {
16535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16536 }
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj;
16545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16546 bool result;
16547 PyObject * obj0 = 0 ;
16548 char *kwnames[] = {
16549 (char *) "self", NULL
16550 };
16551
16552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16554 if (SWIG_arg_fail(1)) SWIG_fail;
16555 {
16556 PyThreadState* __tstate = wxPyBeginAllowThreads();
16557 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16558
16559 wxPyEndAllowThreads(__tstate);
16560 if (PyErr_Occurred()) SWIG_fail;
16561 }
16562 {
16563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16564 }
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16572 PyObject *resultobj;
16573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16574 bool result;
16575 PyObject * obj0 = 0 ;
16576 char *kwnames[] = {
16577 (char *) "self", NULL
16578 };
16579
16580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16582 if (SWIG_arg_fail(1)) SWIG_fail;
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16586
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 {
16591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16592 }
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj;
16601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16602 bool result;
16603 PyObject * obj0 = 0 ;
16604 char *kwnames[] = {
16605 (char *) "self", NULL
16606 };
16607
16608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16610 if (SWIG_arg_fail(1)) SWIG_fail;
16611 {
16612 PyThreadState* __tstate = wxPyBeginAllowThreads();
16613 result = (bool)(arg1)->LeftIsDown();
16614
16615 wxPyEndAllowThreads(__tstate);
16616 if (PyErr_Occurred()) SWIG_fail;
16617 }
16618 {
16619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16620 }
16621 return resultobj;
16622 fail:
16623 return NULL;
16624 }
16625
16626
16627 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16628 PyObject *resultobj;
16629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16630 bool result;
16631 PyObject * obj0 = 0 ;
16632 char *kwnames[] = {
16633 (char *) "self", NULL
16634 };
16635
16636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16638 if (SWIG_arg_fail(1)) SWIG_fail;
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 result = (bool)(arg1)->MiddleIsDown();
16642
16643 wxPyEndAllowThreads(__tstate);
16644 if (PyErr_Occurred()) SWIG_fail;
16645 }
16646 {
16647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16648 }
16649 return resultobj;
16650 fail:
16651 return NULL;
16652 }
16653
16654
16655 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16656 PyObject *resultobj;
16657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16658 bool result;
16659 PyObject * obj0 = 0 ;
16660 char *kwnames[] = {
16661 (char *) "self", NULL
16662 };
16663
16664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16666 if (SWIG_arg_fail(1)) SWIG_fail;
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 result = (bool)(arg1)->RightIsDown();
16670
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 {
16675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16676 }
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj;
16685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16686 bool result;
16687 PyObject * obj0 = 0 ;
16688 char *kwnames[] = {
16689 (char *) "self", NULL
16690 };
16691
16692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16694 if (SWIG_arg_fail(1)) SWIG_fail;
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16698
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 {
16703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16704 }
16705 return resultobj;
16706 fail:
16707 return NULL;
16708 }
16709
16710
16711 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16712 PyObject *resultobj;
16713 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16714 bool result;
16715 PyObject * obj0 = 0 ;
16716 char *kwnames[] = {
16717 (char *) "self", NULL
16718 };
16719
16720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16722 if (SWIG_arg_fail(1)) SWIG_fail;
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16726
16727 wxPyEndAllowThreads(__tstate);
16728 if (PyErr_Occurred()) SWIG_fail;
16729 }
16730 {
16731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16732 }
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj;
16741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16742 bool result;
16743 PyObject * obj0 = 0 ;
16744 char *kwnames[] = {
16745 (char *) "self", NULL
16746 };
16747
16748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16750 if (SWIG_arg_fail(1)) SWIG_fail;
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16754
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 {
16759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16760 }
16761 return resultobj;
16762 fail:
16763 return NULL;
16764 }
16765
16766
16767 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16768 PyObject *resultobj;
16769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16770 bool result;
16771 PyObject * obj0 = 0 ;
16772 char *kwnames[] = {
16773 (char *) "self", NULL
16774 };
16775
16776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16778 if (SWIG_arg_fail(1)) SWIG_fail;
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16782
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 {
16787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16788 }
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj;
16797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16798 wxPoint result;
16799 PyObject * obj0 = 0 ;
16800 char *kwnames[] = {
16801 (char *) "self", NULL
16802 };
16803
16804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16806 if (SWIG_arg_fail(1)) SWIG_fail;
16807 {
16808 PyThreadState* __tstate = wxPyBeginAllowThreads();
16809 result = (arg1)->GetPosition();
16810
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 {
16815 wxPoint * resultptr;
16816 resultptr = new wxPoint((wxPoint &)(result));
16817 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16818 }
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj;
16827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16828 long *arg2 = (long *) 0 ;
16829 long *arg3 = (long *) 0 ;
16830 long temp2 ;
16831 int res2 = 0 ;
16832 long temp3 ;
16833 int res3 = 0 ;
16834 PyObject * obj0 = 0 ;
16835 char *kwnames[] = {
16836 (char *) "self", NULL
16837 };
16838
16839 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16840 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 (arg1)->GetPosition(arg2,arg3);
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 Py_INCREF(Py_None); resultobj = Py_None;
16852 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16853 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16854 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16855 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16865 wxDC *arg2 = 0 ;
16866 wxPoint result;
16867 PyObject * obj0 = 0 ;
16868 PyObject * obj1 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self",(char *) "dc", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 {
16877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16878 if (SWIG_arg_fail(2)) SWIG_fail;
16879 if (arg2 == NULL) {
16880 SWIG_null_ref("wxDC");
16881 }
16882 if (SWIG_arg_fail(2)) SWIG_fail;
16883 }
16884 {
16885 PyThreadState* __tstate = wxPyBeginAllowThreads();
16886 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16887
16888 wxPyEndAllowThreads(__tstate);
16889 if (PyErr_Occurred()) SWIG_fail;
16890 }
16891 {
16892 wxPoint * resultptr;
16893 resultptr = new wxPoint((wxPoint &)(result));
16894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16895 }
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16903 PyObject *resultobj;
16904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16905 int result;
16906 PyObject * obj0 = 0 ;
16907 char *kwnames[] = {
16908 (char *) "self", NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16913 if (SWIG_arg_fail(1)) SWIG_fail;
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (int)((wxMouseEvent const *)arg1)->GetX();
16917
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = SWIG_From_int((int)(result));
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj;
16932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16933 int result;
16934 PyObject * obj0 = 0 ;
16935 char *kwnames[] = {
16936 (char *) "self", NULL
16937 };
16938
16939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (int)((wxMouseEvent const *)arg1)->GetY();
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 {
16950 resultobj = SWIG_From_int((int)(result));
16951 }
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16961 int result;
16962 PyObject * obj0 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16973
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 {
16978 resultobj = SWIG_From_int((int)(result));
16979 }
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16989 int result;
16990 PyObject * obj0 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = SWIG_From_int((int)(result));
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 int result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 {
17034 resultobj = SWIG_From_int((int)(result));
17035 }
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17045 bool result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17073 int arg2 ;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 char *kwnames[] = {
17077 (char *) "self",(char *) "m_x", NULL
17078 };
17079
17080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17082 if (SWIG_arg_fail(1)) SWIG_fail;
17083 {
17084 arg2 = (int)(SWIG_As_int(obj1));
17085 if (SWIG_arg_fail(2)) SWIG_fail;
17086 }
17087 if (arg1) (arg1)->m_x = arg2;
17088
17089 Py_INCREF(Py_None); resultobj = Py_None;
17090 return resultobj;
17091 fail:
17092 return NULL;
17093 }
17094
17095
17096 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17097 PyObject *resultobj;
17098 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17099 int result;
17100 PyObject * obj0 = 0 ;
17101 char *kwnames[] = {
17102 (char *) "self", NULL
17103 };
17104
17105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17107 if (SWIG_arg_fail(1)) SWIG_fail;
17108 result = (int) ((arg1)->m_x);
17109
17110 {
17111 resultobj = SWIG_From_int((int)(result));
17112 }
17113 return resultobj;
17114 fail:
17115 return NULL;
17116 }
17117
17118
17119 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17120 PyObject *resultobj;
17121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17122 int arg2 ;
17123 PyObject * obj0 = 0 ;
17124 PyObject * obj1 = 0 ;
17125 char *kwnames[] = {
17126 (char *) "self",(char *) "m_y", NULL
17127 };
17128
17129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17131 if (SWIG_arg_fail(1)) SWIG_fail;
17132 {
17133 arg2 = (int)(SWIG_As_int(obj1));
17134 if (SWIG_arg_fail(2)) SWIG_fail;
17135 }
17136 if (arg1) (arg1)->m_y = arg2;
17137
17138 Py_INCREF(Py_None); resultobj = Py_None;
17139 return resultobj;
17140 fail:
17141 return NULL;
17142 }
17143
17144
17145 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17146 PyObject *resultobj;
17147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17148 int result;
17149 PyObject * obj0 = 0 ;
17150 char *kwnames[] = {
17151 (char *) "self", NULL
17152 };
17153
17154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17156 if (SWIG_arg_fail(1)) SWIG_fail;
17157 result = (int) ((arg1)->m_y);
17158
17159 {
17160 resultobj = SWIG_From_int((int)(result));
17161 }
17162 return resultobj;
17163 fail:
17164 return NULL;
17165 }
17166
17167
17168 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17169 PyObject *resultobj;
17170 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17171 bool arg2 ;
17172 PyObject * obj0 = 0 ;
17173 PyObject * obj1 = 0 ;
17174 char *kwnames[] = {
17175 (char *) "self",(char *) "m_leftDown", NULL
17176 };
17177
17178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17180 if (SWIG_arg_fail(1)) SWIG_fail;
17181 {
17182 arg2 = (bool)(SWIG_As_bool(obj1));
17183 if (SWIG_arg_fail(2)) SWIG_fail;
17184 }
17185 if (arg1) (arg1)->m_leftDown = arg2;
17186
17187 Py_INCREF(Py_None); resultobj = Py_None;
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj;
17196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17197 bool result;
17198 PyObject * obj0 = 0 ;
17199 char *kwnames[] = {
17200 (char *) "self", NULL
17201 };
17202
17203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17205 if (SWIG_arg_fail(1)) SWIG_fail;
17206 result = (bool) ((arg1)->m_leftDown);
17207
17208 {
17209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17210 }
17211 return resultobj;
17212 fail:
17213 return NULL;
17214 }
17215
17216
17217 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17218 PyObject *resultobj;
17219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17220 bool arg2 ;
17221 PyObject * obj0 = 0 ;
17222 PyObject * obj1 = 0 ;
17223 char *kwnames[] = {
17224 (char *) "self",(char *) "m_middleDown", NULL
17225 };
17226
17227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17229 if (SWIG_arg_fail(1)) SWIG_fail;
17230 {
17231 arg2 = (bool)(SWIG_As_bool(obj1));
17232 if (SWIG_arg_fail(2)) SWIG_fail;
17233 }
17234 if (arg1) (arg1)->m_middleDown = arg2;
17235
17236 Py_INCREF(Py_None); resultobj = Py_None;
17237 return resultobj;
17238 fail:
17239 return NULL;
17240 }
17241
17242
17243 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17244 PyObject *resultobj;
17245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17246 bool result;
17247 PyObject * obj0 = 0 ;
17248 char *kwnames[] = {
17249 (char *) "self", NULL
17250 };
17251
17252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17254 if (SWIG_arg_fail(1)) SWIG_fail;
17255 result = (bool) ((arg1)->m_middleDown);
17256
17257 {
17258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj;
17268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17269 bool arg2 ;
17270 PyObject * obj0 = 0 ;
17271 PyObject * obj1 = 0 ;
17272 char *kwnames[] = {
17273 (char *) "self",(char *) "m_rightDown", NULL
17274 };
17275
17276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17278 if (SWIG_arg_fail(1)) SWIG_fail;
17279 {
17280 arg2 = (bool)(SWIG_As_bool(obj1));
17281 if (SWIG_arg_fail(2)) SWIG_fail;
17282 }
17283 if (arg1) (arg1)->m_rightDown = arg2;
17284
17285 Py_INCREF(Py_None); resultobj = Py_None;
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj;
17294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17295 bool result;
17296 PyObject * obj0 = 0 ;
17297 char *kwnames[] = {
17298 (char *) "self", NULL
17299 };
17300
17301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17303 if (SWIG_arg_fail(1)) SWIG_fail;
17304 result = (bool) ((arg1)->m_rightDown);
17305
17306 {
17307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17308 }
17309 return resultobj;
17310 fail:
17311 return NULL;
17312 }
17313
17314
17315 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17316 PyObject *resultobj;
17317 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17318 bool arg2 ;
17319 PyObject * obj0 = 0 ;
17320 PyObject * obj1 = 0 ;
17321 char *kwnames[] = {
17322 (char *) "self",(char *) "m_controlDown", NULL
17323 };
17324
17325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17327 if (SWIG_arg_fail(1)) SWIG_fail;
17328 {
17329 arg2 = (bool)(SWIG_As_bool(obj1));
17330 if (SWIG_arg_fail(2)) SWIG_fail;
17331 }
17332 if (arg1) (arg1)->m_controlDown = arg2;
17333
17334 Py_INCREF(Py_None); resultobj = Py_None;
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17342 PyObject *resultobj;
17343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17344 bool result;
17345 PyObject * obj0 = 0 ;
17346 char *kwnames[] = {
17347 (char *) "self", NULL
17348 };
17349
17350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17352 if (SWIG_arg_fail(1)) SWIG_fail;
17353 result = (bool) ((arg1)->m_controlDown);
17354
17355 {
17356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17357 }
17358 return resultobj;
17359 fail:
17360 return NULL;
17361 }
17362
17363
17364 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17365 PyObject *resultobj;
17366 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17367 bool arg2 ;
17368 PyObject * obj0 = 0 ;
17369 PyObject * obj1 = 0 ;
17370 char *kwnames[] = {
17371 (char *) "self",(char *) "m_shiftDown", NULL
17372 };
17373
17374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17376 if (SWIG_arg_fail(1)) SWIG_fail;
17377 {
17378 arg2 = (bool)(SWIG_As_bool(obj1));
17379 if (SWIG_arg_fail(2)) SWIG_fail;
17380 }
17381 if (arg1) (arg1)->m_shiftDown = arg2;
17382
17383 Py_INCREF(Py_None); resultobj = Py_None;
17384 return resultobj;
17385 fail:
17386 return NULL;
17387 }
17388
17389
17390 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj;
17392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17393 bool result;
17394 PyObject * obj0 = 0 ;
17395 char *kwnames[] = {
17396 (char *) "self", NULL
17397 };
17398
17399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17401 if (SWIG_arg_fail(1)) SWIG_fail;
17402 result = (bool) ((arg1)->m_shiftDown);
17403
17404 {
17405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17406 }
17407 return resultobj;
17408 fail:
17409 return NULL;
17410 }
17411
17412
17413 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17414 PyObject *resultobj;
17415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17416 bool arg2 ;
17417 PyObject * obj0 = 0 ;
17418 PyObject * obj1 = 0 ;
17419 char *kwnames[] = {
17420 (char *) "self",(char *) "m_altDown", NULL
17421 };
17422
17423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17425 if (SWIG_arg_fail(1)) SWIG_fail;
17426 {
17427 arg2 = (bool)(SWIG_As_bool(obj1));
17428 if (SWIG_arg_fail(2)) SWIG_fail;
17429 }
17430 if (arg1) (arg1)->m_altDown = arg2;
17431
17432 Py_INCREF(Py_None); resultobj = Py_None;
17433 return resultobj;
17434 fail:
17435 return NULL;
17436 }
17437
17438
17439 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj;
17441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17442 bool result;
17443 PyObject * obj0 = 0 ;
17444 char *kwnames[] = {
17445 (char *) "self", NULL
17446 };
17447
17448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 result = (bool) ((arg1)->m_altDown);
17452
17453 {
17454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17455 }
17456 return resultobj;
17457 fail:
17458 return NULL;
17459 }
17460
17461
17462 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17463 PyObject *resultobj;
17464 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17465 bool arg2 ;
17466 PyObject * obj0 = 0 ;
17467 PyObject * obj1 = 0 ;
17468 char *kwnames[] = {
17469 (char *) "self",(char *) "m_metaDown", NULL
17470 };
17471
17472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17474 if (SWIG_arg_fail(1)) SWIG_fail;
17475 {
17476 arg2 = (bool)(SWIG_As_bool(obj1));
17477 if (SWIG_arg_fail(2)) SWIG_fail;
17478 }
17479 if (arg1) (arg1)->m_metaDown = arg2;
17480
17481 Py_INCREF(Py_None); resultobj = Py_None;
17482 return resultobj;
17483 fail:
17484 return NULL;
17485 }
17486
17487
17488 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17489 PyObject *resultobj;
17490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17491 bool result;
17492 PyObject * obj0 = 0 ;
17493 char *kwnames[] = {
17494 (char *) "self", NULL
17495 };
17496
17497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17499 if (SWIG_arg_fail(1)) SWIG_fail;
17500 result = (bool) ((arg1)->m_metaDown);
17501
17502 {
17503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17504 }
17505 return resultobj;
17506 fail:
17507 return NULL;
17508 }
17509
17510
17511 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17512 PyObject *resultobj;
17513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17514 int arg2 ;
17515 PyObject * obj0 = 0 ;
17516 PyObject * obj1 = 0 ;
17517 char *kwnames[] = {
17518 (char *) "self",(char *) "m_wheelRotation", NULL
17519 };
17520
17521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17523 if (SWIG_arg_fail(1)) SWIG_fail;
17524 {
17525 arg2 = (int)(SWIG_As_int(obj1));
17526 if (SWIG_arg_fail(2)) SWIG_fail;
17527 }
17528 if (arg1) (arg1)->m_wheelRotation = arg2;
17529
17530 Py_INCREF(Py_None); resultobj = Py_None;
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj;
17539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17540 int result;
17541 PyObject * obj0 = 0 ;
17542 char *kwnames[] = {
17543 (char *) "self", NULL
17544 };
17545
17546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17548 if (SWIG_arg_fail(1)) SWIG_fail;
17549 result = (int) ((arg1)->m_wheelRotation);
17550
17551 {
17552 resultobj = SWIG_From_int((int)(result));
17553 }
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj;
17562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17563 int arg2 ;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 char *kwnames[] = {
17567 (char *) "self",(char *) "m_wheelDelta", NULL
17568 };
17569
17570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17572 if (SWIG_arg_fail(1)) SWIG_fail;
17573 {
17574 arg2 = (int)(SWIG_As_int(obj1));
17575 if (SWIG_arg_fail(2)) SWIG_fail;
17576 }
17577 if (arg1) (arg1)->m_wheelDelta = arg2;
17578
17579 Py_INCREF(Py_None); resultobj = Py_None;
17580 return resultobj;
17581 fail:
17582 return NULL;
17583 }
17584
17585
17586 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj;
17588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17589 int result;
17590 PyObject * obj0 = 0 ;
17591 char *kwnames[] = {
17592 (char *) "self", NULL
17593 };
17594
17595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17597 if (SWIG_arg_fail(1)) SWIG_fail;
17598 result = (int) ((arg1)->m_wheelDelta);
17599
17600 {
17601 resultobj = SWIG_From_int((int)(result));
17602 }
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17610 PyObject *resultobj;
17611 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17612 int arg2 ;
17613 PyObject * obj0 = 0 ;
17614 PyObject * obj1 = 0 ;
17615 char *kwnames[] = {
17616 (char *) "self",(char *) "m_linesPerAction", NULL
17617 };
17618
17619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17621 if (SWIG_arg_fail(1)) SWIG_fail;
17622 {
17623 arg2 = (int)(SWIG_As_int(obj1));
17624 if (SWIG_arg_fail(2)) SWIG_fail;
17625 }
17626 if (arg1) (arg1)->m_linesPerAction = arg2;
17627
17628 Py_INCREF(Py_None); resultobj = Py_None;
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17636 PyObject *resultobj;
17637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17638 int result;
17639 PyObject * obj0 = 0 ;
17640 char *kwnames[] = {
17641 (char *) "self", NULL
17642 };
17643
17644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17646 if (SWIG_arg_fail(1)) SWIG_fail;
17647 result = (int) ((arg1)->m_linesPerAction);
17648
17649 {
17650 resultobj = SWIG_From_int((int)(result));
17651 }
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17659 PyObject *obj;
17660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17661 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17662 Py_INCREF(obj);
17663 return Py_BuildValue((char *)"");
17664 }
17665 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 int arg1 = (int) 0 ;
17668 int arg2 = (int) 0 ;
17669 wxSetCursorEvent *result;
17670 PyObject * obj0 = 0 ;
17671 PyObject * obj1 = 0 ;
17672 char *kwnames[] = {
17673 (char *) "x",(char *) "y", NULL
17674 };
17675
17676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17677 if (obj0) {
17678 {
17679 arg1 = (int)(SWIG_As_int(obj0));
17680 if (SWIG_arg_fail(1)) SWIG_fail;
17681 }
17682 }
17683 if (obj1) {
17684 {
17685 arg2 = (int)(SWIG_As_int(obj1));
17686 if (SWIG_arg_fail(2)) SWIG_fail;
17687 }
17688 }
17689 {
17690 PyThreadState* __tstate = wxPyBeginAllowThreads();
17691 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17692
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj;
17705 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17706 int result;
17707 PyObject * obj0 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 {
17716 PyThreadState* __tstate = wxPyBeginAllowThreads();
17717 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17718
17719 wxPyEndAllowThreads(__tstate);
17720 if (PyErr_Occurred()) SWIG_fail;
17721 }
17722 {
17723 resultobj = SWIG_From_int((int)(result));
17724 }
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj;
17733 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17734 int result;
17735 PyObject * obj0 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "self", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17742 if (SWIG_arg_fail(1)) SWIG_fail;
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17746
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = SWIG_From_int((int)(result));
17752 }
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj;
17761 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17762 wxCursor *arg2 = 0 ;
17763 PyObject * obj0 = 0 ;
17764 PyObject * obj1 = 0 ;
17765 char *kwnames[] = {
17766 (char *) "self",(char *) "cursor", NULL
17767 };
17768
17769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17771 if (SWIG_arg_fail(1)) SWIG_fail;
17772 {
17773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17774 if (SWIG_arg_fail(2)) SWIG_fail;
17775 if (arg2 == NULL) {
17776 SWIG_null_ref("wxCursor");
17777 }
17778 if (SWIG_arg_fail(2)) SWIG_fail;
17779 }
17780 {
17781 PyThreadState* __tstate = wxPyBeginAllowThreads();
17782 (arg1)->SetCursor((wxCursor const &)*arg2);
17783
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 Py_INCREF(Py_None); resultobj = Py_None;
17788 return resultobj;
17789 fail:
17790 return NULL;
17791 }
17792
17793
17794 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17795 PyObject *resultobj;
17796 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17797 wxCursor *result;
17798 PyObject * obj0 = 0 ;
17799 char *kwnames[] = {
17800 (char *) "self", NULL
17801 };
17802
17803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17805 if (SWIG_arg_fail(1)) SWIG_fail;
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 {
17809 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17810 result = (wxCursor *) &_result_ref;
17811 }
17812
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 wxCursor* resultptr = new wxCursor(*result);
17818 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17819 }
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17829 bool result;
17830 PyObject * obj0 = 0 ;
17831 char *kwnames[] = {
17832 (char *) "self", NULL
17833 };
17834
17835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17837 if (SWIG_arg_fail(1)) SWIG_fail;
17838 {
17839 PyThreadState* __tstate = wxPyBeginAllowThreads();
17840 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17841
17842 wxPyEndAllowThreads(__tstate);
17843 if (PyErr_Occurred()) SWIG_fail;
17844 }
17845 {
17846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17847 }
17848 return resultobj;
17849 fail:
17850 return NULL;
17851 }
17852
17853
17854 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17855 PyObject *obj;
17856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17857 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17858 Py_INCREF(obj);
17859 return Py_BuildValue((char *)"");
17860 }
17861 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj;
17863 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17864 wxKeyEvent *result;
17865 PyObject * obj0 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "keyType", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17871 if (obj0) {
17872 {
17873 arg1 = (wxEventType)(SWIG_As_int(obj0));
17874 if (SWIG_arg_fail(1)) SWIG_fail;
17875 }
17876 }
17877 {
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17880
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17892 PyObject *resultobj;
17893 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17894 bool result;
17895 PyObject * obj0 = 0 ;
17896 char *kwnames[] = {
17897 (char *) "self", NULL
17898 };
17899
17900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17902 if (SWIG_arg_fail(1)) SWIG_fail;
17903 {
17904 PyThreadState* __tstate = wxPyBeginAllowThreads();
17905 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17906
17907 wxPyEndAllowThreads(__tstate);
17908 if (PyErr_Occurred()) SWIG_fail;
17909 }
17910 {
17911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17912 }
17913 return resultobj;
17914 fail:
17915 return NULL;
17916 }
17917
17918
17919 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17920 PyObject *resultobj;
17921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17922 bool result;
17923 PyObject * obj0 = 0 ;
17924 char *kwnames[] = {
17925 (char *) "self", NULL
17926 };
17927
17928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17930 if (SWIG_arg_fail(1)) SWIG_fail;
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17934
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17948 PyObject *resultobj;
17949 wxKeyEvent *arg1 = (wxKeyEvent *) 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:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17958 if (SWIG_arg_fail(1)) SWIG_fail;
17959 {
17960 PyThreadState* __tstate = wxPyBeginAllowThreads();
17961 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17962
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 {
17967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17968 }
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17976 PyObject *resultobj;
17977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17978 bool result;
17979 PyObject * obj0 = 0 ;
17980 char *kwnames[] = {
17981 (char *) "self", NULL
17982 };
17983
17984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17986 if (SWIG_arg_fail(1)) SWIG_fail;
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17990
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 {
17995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17996 }
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18004 PyObject *resultobj;
18005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18006 bool result;
18007 PyObject * obj0 = 0 ;
18008 char *kwnames[] = {
18009 (char *) "self", NULL
18010 };
18011
18012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(1)) SWIG_fail;
18015 {
18016 PyThreadState* __tstate = wxPyBeginAllowThreads();
18017 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18018
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18034 bool result;
18035 PyObject * obj0 = 0 ;
18036 char *kwnames[] = {
18037 (char *) "self", NULL
18038 };
18039
18040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18042 if (SWIG_arg_fail(1)) SWIG_fail;
18043 {
18044 PyThreadState* __tstate = wxPyBeginAllowThreads();
18045 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18046
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 {
18051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18052 }
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18060 PyObject *resultobj;
18061 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18062 int result;
18063 PyObject * obj0 = 0 ;
18064 char *kwnames[] = {
18065 (char *) "self", NULL
18066 };
18067
18068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18070 if (SWIG_arg_fail(1)) SWIG_fail;
18071 {
18072 PyThreadState* __tstate = wxPyBeginAllowThreads();
18073 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18074
18075 wxPyEndAllowThreads(__tstate);
18076 if (PyErr_Occurred()) SWIG_fail;
18077 }
18078 {
18079 resultobj = SWIG_From_int((int)(result));
18080 }
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj;
18089 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18090 int result;
18091 PyObject * obj0 = 0 ;
18092 char *kwnames[] = {
18093 (char *) "self", NULL
18094 };
18095
18096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18098 if (SWIG_arg_fail(1)) SWIG_fail;
18099 {
18100 PyThreadState* __tstate = wxPyBeginAllowThreads();
18101 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18102
18103 wxPyEndAllowThreads(__tstate);
18104 if (PyErr_Occurred()) SWIG_fail;
18105 }
18106 {
18107 resultobj = SWIG_From_int((int)(result));
18108 }
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18116 PyObject *resultobj;
18117 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18118 unsigned int result;
18119 PyObject * obj0 = 0 ;
18120 char *kwnames[] = {
18121 (char *) "self", NULL
18122 };
18123
18124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18126 if (SWIG_arg_fail(1)) SWIG_fail;
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18130
18131 wxPyEndAllowThreads(__tstate);
18132 if (PyErr_Occurred()) SWIG_fail;
18133 }
18134 {
18135 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18136 }
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj;
18145 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18146 unsigned int result;
18147 PyObject * obj0 = 0 ;
18148 char *kwnames[] = {
18149 (char *) "self", NULL
18150 };
18151
18152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18154 if (SWIG_arg_fail(1)) SWIG_fail;
18155 {
18156 PyThreadState* __tstate = wxPyBeginAllowThreads();
18157 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18158
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 {
18163 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18164 }
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18172 PyObject *resultobj;
18173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18174 wxPoint result;
18175 PyObject * obj0 = 0 ;
18176 char *kwnames[] = {
18177 (char *) "self", NULL
18178 };
18179
18180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18182 if (SWIG_arg_fail(1)) SWIG_fail;
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 result = (arg1)->GetPosition();
18186
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 {
18191 wxPoint * resultptr;
18192 resultptr = new wxPoint((wxPoint &)(result));
18193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18194 }
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj;
18203 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18204 long *arg2 = (long *) 0 ;
18205 long *arg3 = (long *) 0 ;
18206 long temp2 ;
18207 int res2 = 0 ;
18208 long temp3 ;
18209 int res3 = 0 ;
18210 PyObject * obj0 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "self", NULL
18213 };
18214
18215 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18216 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 {
18221 PyThreadState* __tstate = wxPyBeginAllowThreads();
18222 (arg1)->GetPosition(arg2,arg3);
18223
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 Py_INCREF(Py_None); resultobj = Py_None;
18228 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18229 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18230 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18231 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18239 PyObject *resultobj;
18240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18241 int result;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (int)((wxKeyEvent const *)arg1)->GetX();
18253
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 {
18258 resultobj = SWIG_From_int((int)(result));
18259 }
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj;
18268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18269 int result;
18270 PyObject * obj0 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "self", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18277 if (SWIG_arg_fail(1)) SWIG_fail;
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (int)((wxKeyEvent const *)arg1)->GetY();
18281
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 {
18286 resultobj = SWIG_From_int((int)(result));
18287 }
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj;
18296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18297 int arg2 ;
18298 PyObject * obj0 = 0 ;
18299 PyObject * obj1 = 0 ;
18300 char *kwnames[] = {
18301 (char *) "self",(char *) "m_x", NULL
18302 };
18303
18304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18306 if (SWIG_arg_fail(1)) SWIG_fail;
18307 {
18308 arg2 = (int)(SWIG_As_int(obj1));
18309 if (SWIG_arg_fail(2)) SWIG_fail;
18310 }
18311 if (arg1) (arg1)->m_x = arg2;
18312
18313 Py_INCREF(Py_None); resultobj = Py_None;
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj;
18322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18323 int result;
18324 PyObject * obj0 = 0 ;
18325 char *kwnames[] = {
18326 (char *) "self", NULL
18327 };
18328
18329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18331 if (SWIG_arg_fail(1)) SWIG_fail;
18332 result = (int) ((arg1)->m_x);
18333
18334 {
18335 resultobj = SWIG_From_int((int)(result));
18336 }
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18344 PyObject *resultobj;
18345 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18346 int arg2 ;
18347 PyObject * obj0 = 0 ;
18348 PyObject * obj1 = 0 ;
18349 char *kwnames[] = {
18350 (char *) "self",(char *) "m_y", NULL
18351 };
18352
18353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18355 if (SWIG_arg_fail(1)) SWIG_fail;
18356 {
18357 arg2 = (int)(SWIG_As_int(obj1));
18358 if (SWIG_arg_fail(2)) SWIG_fail;
18359 }
18360 if (arg1) (arg1)->m_y = arg2;
18361
18362 Py_INCREF(Py_None); resultobj = Py_None;
18363 return resultobj;
18364 fail:
18365 return NULL;
18366 }
18367
18368
18369 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj;
18371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18372 int result;
18373 PyObject * obj0 = 0 ;
18374 char *kwnames[] = {
18375 (char *) "self", NULL
18376 };
18377
18378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18380 if (SWIG_arg_fail(1)) SWIG_fail;
18381 result = (int) ((arg1)->m_y);
18382
18383 {
18384 resultobj = SWIG_From_int((int)(result));
18385 }
18386 return resultobj;
18387 fail:
18388 return NULL;
18389 }
18390
18391
18392 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18393 PyObject *resultobj;
18394 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18395 long arg2 ;
18396 PyObject * obj0 = 0 ;
18397 PyObject * obj1 = 0 ;
18398 char *kwnames[] = {
18399 (char *) "self",(char *) "m_keyCode", NULL
18400 };
18401
18402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18404 if (SWIG_arg_fail(1)) SWIG_fail;
18405 {
18406 arg2 = (long)(SWIG_As_long(obj1));
18407 if (SWIG_arg_fail(2)) SWIG_fail;
18408 }
18409 if (arg1) (arg1)->m_keyCode = arg2;
18410
18411 Py_INCREF(Py_None); resultobj = Py_None;
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18421 long result;
18422 PyObject * obj0 = 0 ;
18423 char *kwnames[] = {
18424 (char *) "self", NULL
18425 };
18426
18427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18429 if (SWIG_arg_fail(1)) SWIG_fail;
18430 result = (long) ((arg1)->m_keyCode);
18431
18432 {
18433 resultobj = SWIG_From_long((long)(result));
18434 }
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj;
18443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18444 bool arg2 ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 char *kwnames[] = {
18448 (char *) "self",(char *) "m_controlDown", NULL
18449 };
18450
18451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18453 if (SWIG_arg_fail(1)) SWIG_fail;
18454 {
18455 arg2 = (bool)(SWIG_As_bool(obj1));
18456 if (SWIG_arg_fail(2)) SWIG_fail;
18457 }
18458 if (arg1) (arg1)->m_controlDown = arg2;
18459
18460 Py_INCREF(Py_None); resultobj = Py_None;
18461 return resultobj;
18462 fail:
18463 return NULL;
18464 }
18465
18466
18467 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18468 PyObject *resultobj;
18469 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18470 bool result;
18471 PyObject * obj0 = 0 ;
18472 char *kwnames[] = {
18473 (char *) "self", NULL
18474 };
18475
18476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18478 if (SWIG_arg_fail(1)) SWIG_fail;
18479 result = (bool) ((arg1)->m_controlDown);
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_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18491 PyObject *resultobj;
18492 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18493 bool arg2 ;
18494 PyObject * obj0 = 0 ;
18495 PyObject * obj1 = 0 ;
18496 char *kwnames[] = {
18497 (char *) "self",(char *) "m_shiftDown", NULL
18498 };
18499
18500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(1)) SWIG_fail;
18503 {
18504 arg2 = (bool)(SWIG_As_bool(obj1));
18505 if (SWIG_arg_fail(2)) SWIG_fail;
18506 }
18507 if (arg1) (arg1)->m_shiftDown = arg2;
18508
18509 Py_INCREF(Py_None); resultobj = Py_None;
18510 return resultobj;
18511 fail:
18512 return NULL;
18513 }
18514
18515
18516 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18517 PyObject *resultobj;
18518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18519 bool result;
18520 PyObject * obj0 = 0 ;
18521 char *kwnames[] = {
18522 (char *) "self", NULL
18523 };
18524
18525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18527 if (SWIG_arg_fail(1)) SWIG_fail;
18528 result = (bool) ((arg1)->m_shiftDown);
18529
18530 {
18531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18532 }
18533 return resultobj;
18534 fail:
18535 return NULL;
18536 }
18537
18538
18539 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18540 PyObject *resultobj;
18541 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18542 bool arg2 ;
18543 PyObject * obj0 = 0 ;
18544 PyObject * obj1 = 0 ;
18545 char *kwnames[] = {
18546 (char *) "self",(char *) "m_altDown", NULL
18547 };
18548
18549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18551 if (SWIG_arg_fail(1)) SWIG_fail;
18552 {
18553 arg2 = (bool)(SWIG_As_bool(obj1));
18554 if (SWIG_arg_fail(2)) SWIG_fail;
18555 }
18556 if (arg1) (arg1)->m_altDown = arg2;
18557
18558 Py_INCREF(Py_None); resultobj = Py_None;
18559 return resultobj;
18560 fail:
18561 return NULL;
18562 }
18563
18564
18565 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18566 PyObject *resultobj;
18567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18568 bool result;
18569 PyObject * obj0 = 0 ;
18570 char *kwnames[] = {
18571 (char *) "self", NULL
18572 };
18573
18574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18576 if (SWIG_arg_fail(1)) SWIG_fail;
18577 result = (bool) ((arg1)->m_altDown);
18578
18579 {
18580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18581 }
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj;
18590 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18591 bool arg2 ;
18592 PyObject * obj0 = 0 ;
18593 PyObject * obj1 = 0 ;
18594 char *kwnames[] = {
18595 (char *) "self",(char *) "m_metaDown", NULL
18596 };
18597
18598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18600 if (SWIG_arg_fail(1)) SWIG_fail;
18601 {
18602 arg2 = (bool)(SWIG_As_bool(obj1));
18603 if (SWIG_arg_fail(2)) SWIG_fail;
18604 }
18605 if (arg1) (arg1)->m_metaDown = arg2;
18606
18607 Py_INCREF(Py_None); resultobj = Py_None;
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj;
18616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18617 bool result;
18618 PyObject * obj0 = 0 ;
18619 char *kwnames[] = {
18620 (char *) "self", NULL
18621 };
18622
18623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 result = (bool) ((arg1)->m_metaDown);
18627
18628 {
18629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18630 }
18631 return resultobj;
18632 fail:
18633 return NULL;
18634 }
18635
18636
18637 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18638 PyObject *resultobj;
18639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18640 bool arg2 ;
18641 PyObject * obj0 = 0 ;
18642 PyObject * obj1 = 0 ;
18643 char *kwnames[] = {
18644 (char *) "self",(char *) "m_scanCode", NULL
18645 };
18646
18647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18649 if (SWIG_arg_fail(1)) SWIG_fail;
18650 {
18651 arg2 = (bool)(SWIG_As_bool(obj1));
18652 if (SWIG_arg_fail(2)) SWIG_fail;
18653 }
18654 if (arg1) (arg1)->m_scanCode = arg2;
18655
18656 Py_INCREF(Py_None); resultobj = Py_None;
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18664 PyObject *resultobj;
18665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18666 bool result;
18667 PyObject * obj0 = 0 ;
18668 char *kwnames[] = {
18669 (char *) "self", NULL
18670 };
18671
18672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18674 if (SWIG_arg_fail(1)) SWIG_fail;
18675 result = (bool) ((arg1)->m_scanCode);
18676
18677 {
18678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18679 }
18680 return resultobj;
18681 fail:
18682 return NULL;
18683 }
18684
18685
18686 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18687 PyObject *resultobj;
18688 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18689 unsigned int arg2 ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 char *kwnames[] = {
18693 (char *) "self",(char *) "m_rawCode", NULL
18694 };
18695
18696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18698 if (SWIG_arg_fail(1)) SWIG_fail;
18699 {
18700 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18701 if (SWIG_arg_fail(2)) SWIG_fail;
18702 }
18703 if (arg1) (arg1)->m_rawCode = arg2;
18704
18705 Py_INCREF(Py_None); resultobj = Py_None;
18706 return resultobj;
18707 fail:
18708 return NULL;
18709 }
18710
18711
18712 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18713 PyObject *resultobj;
18714 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18715 unsigned int result;
18716 PyObject * obj0 = 0 ;
18717 char *kwnames[] = {
18718 (char *) "self", NULL
18719 };
18720
18721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18723 if (SWIG_arg_fail(1)) SWIG_fail;
18724 result = (unsigned int) ((arg1)->m_rawCode);
18725
18726 {
18727 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18728 }
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj;
18737 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18738 unsigned int arg2 ;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self",(char *) "m_rawFlags", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 {
18749 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18750 if (SWIG_arg_fail(2)) SWIG_fail;
18751 }
18752 if (arg1) (arg1)->m_rawFlags = arg2;
18753
18754 Py_INCREF(Py_None); resultobj = Py_None;
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj;
18763 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18764 unsigned int result;
18765 PyObject * obj0 = 0 ;
18766 char *kwnames[] = {
18767 (char *) "self", NULL
18768 };
18769
18770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18772 if (SWIG_arg_fail(1)) SWIG_fail;
18773 result = (unsigned int) ((arg1)->m_rawFlags);
18774
18775 {
18776 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18777 }
18778 return resultobj;
18779 fail:
18780 return NULL;
18781 }
18782
18783
18784 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18785 PyObject *obj;
18786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18787 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18788 Py_INCREF(obj);
18789 return Py_BuildValue((char *)"");
18790 }
18791 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18792 PyObject *resultobj;
18793 wxSize const &arg1_defvalue = wxDefaultSize ;
18794 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18795 int arg2 = (int) 0 ;
18796 wxSizeEvent *result;
18797 wxSize temp1 ;
18798 PyObject * obj0 = 0 ;
18799 PyObject * obj1 = 0 ;
18800 char *kwnames[] = {
18801 (char *) "sz",(char *) "winid", NULL
18802 };
18803
18804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18805 if (obj0) {
18806 {
18807 arg1 = &temp1;
18808 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18809 }
18810 }
18811 if (obj1) {
18812 {
18813 arg2 = (int)(SWIG_As_int(obj1));
18814 if (SWIG_arg_fail(2)) SWIG_fail;
18815 }
18816 }
18817 {
18818 PyThreadState* __tstate = wxPyBeginAllowThreads();
18819 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18820
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj;
18833 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18834 wxSize result;
18835 PyObject * obj0 = 0 ;
18836 char *kwnames[] = {
18837 (char *) "self", NULL
18838 };
18839
18840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18842 if (SWIG_arg_fail(1)) SWIG_fail;
18843 {
18844 PyThreadState* __tstate = wxPyBeginAllowThreads();
18845 result = ((wxSizeEvent const *)arg1)->GetSize();
18846
18847 wxPyEndAllowThreads(__tstate);
18848 if (PyErr_Occurred()) SWIG_fail;
18849 }
18850 {
18851 wxSize * resultptr;
18852 resultptr = new wxSize((wxSize &)(result));
18853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18854 }
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj;
18863 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18864 wxRect result;
18865 PyObject * obj0 = 0 ;
18866 char *kwnames[] = {
18867 (char *) "self", NULL
18868 };
18869
18870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18872 if (SWIG_arg_fail(1)) SWIG_fail;
18873 {
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 result = ((wxSizeEvent const *)arg1)->GetRect();
18876
18877 wxPyEndAllowThreads(__tstate);
18878 if (PyErr_Occurred()) SWIG_fail;
18879 }
18880 {
18881 wxRect * resultptr;
18882 resultptr = new wxRect((wxRect &)(result));
18883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18884 }
18885 return resultobj;
18886 fail:
18887 return NULL;
18888 }
18889
18890
18891 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18892 PyObject *resultobj;
18893 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18894 wxRect arg2 ;
18895 PyObject * obj0 = 0 ;
18896 PyObject * obj1 = 0 ;
18897 char *kwnames[] = {
18898 (char *) "self",(char *) "rect", NULL
18899 };
18900
18901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18903 if (SWIG_arg_fail(1)) SWIG_fail;
18904 {
18905 wxRect * argp;
18906 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18907 if (SWIG_arg_fail(2)) SWIG_fail;
18908 if (argp == NULL) {
18909 SWIG_null_ref("wxRect");
18910 }
18911 if (SWIG_arg_fail(2)) SWIG_fail;
18912 arg2 = *argp;
18913 }
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 (arg1)->SetRect(arg2);
18917
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 Py_INCREF(Py_None); resultobj = Py_None;
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj;
18930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18931 wxSize arg2 ;
18932 PyObject * obj0 = 0 ;
18933 PyObject * obj1 = 0 ;
18934 char *kwnames[] = {
18935 (char *) "self",(char *) "size", NULL
18936 };
18937
18938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18940 if (SWIG_arg_fail(1)) SWIG_fail;
18941 {
18942 wxSize * argp;
18943 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18944 if (SWIG_arg_fail(2)) SWIG_fail;
18945 if (argp == NULL) {
18946 SWIG_null_ref("wxSize");
18947 }
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 arg2 = *argp;
18950 }
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 wxSizeEvent_SetSize(arg1,arg2);
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 Py_INCREF(Py_None); resultobj = Py_None;
18959 return resultobj;
18960 fail:
18961 return NULL;
18962 }
18963
18964
18965 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18966 PyObject *resultobj;
18967 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18968 wxSize *arg2 = (wxSize *) 0 ;
18969 PyObject * obj0 = 0 ;
18970 PyObject * obj1 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self",(char *) "m_size", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18979 if (SWIG_arg_fail(2)) SWIG_fail;
18980 if (arg1) (arg1)->m_size = *arg2;
18981
18982 Py_INCREF(Py_None); resultobj = Py_None;
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj;
18991 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18992 wxSize *result;
18993 PyObject * obj0 = 0 ;
18994 char *kwnames[] = {
18995 (char *) "self", NULL
18996 };
18997
18998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19000 if (SWIG_arg_fail(1)) SWIG_fail;
19001 result = (wxSize *)& ((arg1)->m_size);
19002
19003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19004 return resultobj;
19005 fail:
19006 return NULL;
19007 }
19008
19009
19010 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19011 PyObject *resultobj;
19012 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19013 wxRect *arg2 = (wxRect *) 0 ;
19014 PyObject * obj0 = 0 ;
19015 PyObject * obj1 = 0 ;
19016 char *kwnames[] = {
19017 (char *) "self",(char *) "m_rect", NULL
19018 };
19019
19020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19022 if (SWIG_arg_fail(1)) SWIG_fail;
19023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19024 if (SWIG_arg_fail(2)) SWIG_fail;
19025 if (arg1) (arg1)->m_rect = *arg2;
19026
19027 Py_INCREF(Py_None); resultobj = Py_None;
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj;
19036 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19037 wxRect *result;
19038 PyObject * obj0 = 0 ;
19039 char *kwnames[] = {
19040 (char *) "self", NULL
19041 };
19042
19043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19045 if (SWIG_arg_fail(1)) SWIG_fail;
19046 result = (wxRect *)& ((arg1)->m_rect);
19047
19048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19049 return resultobj;
19050 fail:
19051 return NULL;
19052 }
19053
19054
19055 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19056 PyObject *obj;
19057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19058 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19059 Py_INCREF(obj);
19060 return Py_BuildValue((char *)"");
19061 }
19062 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19063 PyObject *resultobj;
19064 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19065 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19066 int arg2 = (int) 0 ;
19067 wxMoveEvent *result;
19068 wxPoint temp1 ;
19069 PyObject * obj0 = 0 ;
19070 PyObject * obj1 = 0 ;
19071 char *kwnames[] = {
19072 (char *) "pos",(char *) "winid", NULL
19073 };
19074
19075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19076 if (obj0) {
19077 {
19078 arg1 = &temp1;
19079 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19080 }
19081 }
19082 if (obj1) {
19083 {
19084 arg2 = (int)(SWIG_As_int(obj1));
19085 if (SWIG_arg_fail(2)) SWIG_fail;
19086 }
19087 }
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19091
19092 wxPyEndAllowThreads(__tstate);
19093 if (PyErr_Occurred()) SWIG_fail;
19094 }
19095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19096 return resultobj;
19097 fail:
19098 return NULL;
19099 }
19100
19101
19102 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19103 PyObject *resultobj;
19104 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19105 wxPoint result;
19106 PyObject * obj0 = 0 ;
19107 char *kwnames[] = {
19108 (char *) "self", NULL
19109 };
19110
19111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19113 if (SWIG_arg_fail(1)) SWIG_fail;
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = ((wxMoveEvent const *)arg1)->GetPosition();
19117
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 {
19122 wxPoint * resultptr;
19123 resultptr = new wxPoint((wxPoint &)(result));
19124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19125 }
19126 return resultobj;
19127 fail:
19128 return NULL;
19129 }
19130
19131
19132 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19133 PyObject *resultobj;
19134 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19135 wxRect result;
19136 PyObject * obj0 = 0 ;
19137 char *kwnames[] = {
19138 (char *) "self", NULL
19139 };
19140
19141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19143 if (SWIG_arg_fail(1)) SWIG_fail;
19144 {
19145 PyThreadState* __tstate = wxPyBeginAllowThreads();
19146 result = ((wxMoveEvent const *)arg1)->GetRect();
19147
19148 wxPyEndAllowThreads(__tstate);
19149 if (PyErr_Occurred()) SWIG_fail;
19150 }
19151 {
19152 wxRect * resultptr;
19153 resultptr = new wxRect((wxRect &)(result));
19154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19155 }
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj;
19164 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19165 wxRect *arg2 = 0 ;
19166 wxRect temp2 ;
19167 PyObject * obj0 = 0 ;
19168 PyObject * obj1 = 0 ;
19169 char *kwnames[] = {
19170 (char *) "self",(char *) "rect", NULL
19171 };
19172
19173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19175 if (SWIG_arg_fail(1)) SWIG_fail;
19176 {
19177 arg2 = &temp2;
19178 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19179 }
19180 {
19181 PyThreadState* __tstate = wxPyBeginAllowThreads();
19182 (arg1)->SetRect((wxRect const &)*arg2);
19183
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 Py_INCREF(Py_None); resultobj = Py_None;
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19195 PyObject *resultobj;
19196 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19197 wxPoint *arg2 = 0 ;
19198 wxPoint temp2 ;
19199 PyObject * obj0 = 0 ;
19200 PyObject * obj1 = 0 ;
19201 char *kwnames[] = {
19202 (char *) "self",(char *) "pos", NULL
19203 };
19204
19205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19207 if (SWIG_arg_fail(1)) SWIG_fail;
19208 {
19209 arg2 = &temp2;
19210 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19211 }
19212 {
19213 PyThreadState* __tstate = wxPyBeginAllowThreads();
19214 (arg1)->SetPosition((wxPoint const &)*arg2);
19215
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 Py_INCREF(Py_None); resultobj = Py_None;
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19227 PyObject *obj;
19228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19229 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19230 Py_INCREF(obj);
19231 return Py_BuildValue((char *)"");
19232 }
19233 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19234 PyObject *resultobj;
19235 int arg1 = (int) 0 ;
19236 wxPaintEvent *result;
19237 PyObject * obj0 = 0 ;
19238 char *kwnames[] = {
19239 (char *) "Id", NULL
19240 };
19241
19242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19243 if (obj0) {
19244 {
19245 arg1 = (int)(SWIG_As_int(obj0));
19246 if (SWIG_arg_fail(1)) SWIG_fail;
19247 }
19248 }
19249 {
19250 PyThreadState* __tstate = wxPyBeginAllowThreads();
19251 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19252
19253 wxPyEndAllowThreads(__tstate);
19254 if (PyErr_Occurred()) SWIG_fail;
19255 }
19256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19257 return resultobj;
19258 fail:
19259 return NULL;
19260 }
19261
19262
19263 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19264 PyObject *obj;
19265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19266 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19267 Py_INCREF(obj);
19268 return Py_BuildValue((char *)"");
19269 }
19270 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19271 PyObject *resultobj;
19272 int arg1 = (int) 0 ;
19273 wxNcPaintEvent *result;
19274 PyObject * obj0 = 0 ;
19275 char *kwnames[] = {
19276 (char *) "winid", NULL
19277 };
19278
19279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19280 if (obj0) {
19281 {
19282 arg1 = (int)(SWIG_As_int(obj0));
19283 if (SWIG_arg_fail(1)) SWIG_fail;
19284 }
19285 }
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19289
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19301 PyObject *obj;
19302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19303 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19304 Py_INCREF(obj);
19305 return Py_BuildValue((char *)"");
19306 }
19307 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19308 PyObject *resultobj;
19309 int arg1 = (int) 0 ;
19310 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19311 wxEraseEvent *result;
19312 PyObject * obj0 = 0 ;
19313 PyObject * obj1 = 0 ;
19314 char *kwnames[] = {
19315 (char *) "Id",(char *) "dc", NULL
19316 };
19317
19318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19319 if (obj0) {
19320 {
19321 arg1 = (int)(SWIG_As_int(obj0));
19322 if (SWIG_arg_fail(1)) SWIG_fail;
19323 }
19324 }
19325 if (obj1) {
19326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19327 if (SWIG_arg_fail(2)) SWIG_fail;
19328 }
19329 {
19330 PyThreadState* __tstate = wxPyBeginAllowThreads();
19331 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19332
19333 wxPyEndAllowThreads(__tstate);
19334 if (PyErr_Occurred()) SWIG_fail;
19335 }
19336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19337 return resultobj;
19338 fail:
19339 return NULL;
19340 }
19341
19342
19343 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19344 PyObject *resultobj;
19345 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19346 wxDC *result;
19347 PyObject * obj0 = 0 ;
19348 char *kwnames[] = {
19349 (char *) "self", NULL
19350 };
19351
19352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19354 if (SWIG_arg_fail(1)) SWIG_fail;
19355 {
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19358
19359 wxPyEndAllowThreads(__tstate);
19360 if (PyErr_Occurred()) SWIG_fail;
19361 }
19362 {
19363 resultobj = wxPyMake_wxObject(result, 0);
19364 }
19365 return resultobj;
19366 fail:
19367 return NULL;
19368 }
19369
19370
19371 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19372 PyObject *obj;
19373 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19374 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19375 Py_INCREF(obj);
19376 return Py_BuildValue((char *)"");
19377 }
19378 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj;
19380 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19381 int arg2 = (int) 0 ;
19382 wxFocusEvent *result;
19383 PyObject * obj0 = 0 ;
19384 PyObject * obj1 = 0 ;
19385 char *kwnames[] = {
19386 (char *) "type",(char *) "winid", NULL
19387 };
19388
19389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19390 if (obj0) {
19391 {
19392 arg1 = (wxEventType)(SWIG_As_int(obj0));
19393 if (SWIG_arg_fail(1)) SWIG_fail;
19394 }
19395 }
19396 if (obj1) {
19397 {
19398 arg2 = (int)(SWIG_As_int(obj1));
19399 if (SWIG_arg_fail(2)) SWIG_fail;
19400 }
19401 }
19402 {
19403 PyThreadState* __tstate = wxPyBeginAllowThreads();
19404 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19405
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19417 PyObject *resultobj;
19418 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19419 wxWindow *result;
19420 PyObject * obj0 = 0 ;
19421 char *kwnames[] = {
19422 (char *) "self", NULL
19423 };
19424
19425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19427 if (SWIG_arg_fail(1)) SWIG_fail;
19428 {
19429 PyThreadState* __tstate = wxPyBeginAllowThreads();
19430 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19431
19432 wxPyEndAllowThreads(__tstate);
19433 if (PyErr_Occurred()) SWIG_fail;
19434 }
19435 {
19436 resultobj = wxPyMake_wxObject(result, 0);
19437 }
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj;
19446 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19447 wxWindow *arg2 = (wxWindow *) 0 ;
19448 PyObject * obj0 = 0 ;
19449 PyObject * obj1 = 0 ;
19450 char *kwnames[] = {
19451 (char *) "self",(char *) "win", NULL
19452 };
19453
19454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19456 if (SWIG_arg_fail(1)) SWIG_fail;
19457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19458 if (SWIG_arg_fail(2)) SWIG_fail;
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 (arg1)->SetWindow(arg2);
19462
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 Py_INCREF(Py_None); resultobj = Py_None;
19467 return resultobj;
19468 fail:
19469 return NULL;
19470 }
19471
19472
19473 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19474 PyObject *obj;
19475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19476 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19477 Py_INCREF(obj);
19478 return Py_BuildValue((char *)"");
19479 }
19480 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19481 PyObject *resultobj;
19482 wxWindow *arg1 = (wxWindow *) NULL ;
19483 wxChildFocusEvent *result;
19484 PyObject * obj0 = 0 ;
19485 char *kwnames[] = {
19486 (char *) "win", NULL
19487 };
19488
19489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19490 if (obj0) {
19491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19492 if (SWIG_arg_fail(1)) SWIG_fail;
19493 }
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19497
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19509 PyObject *resultobj;
19510 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19511 wxWindow *result;
19512 PyObject * obj0 = 0 ;
19513 char *kwnames[] = {
19514 (char *) "self", NULL
19515 };
19516
19517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19519 if (SWIG_arg_fail(1)) SWIG_fail;
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19523
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 {
19528 resultobj = wxPyMake_wxObject(result, 0);
19529 }
19530 return resultobj;
19531 fail:
19532 return NULL;
19533 }
19534
19535
19536 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19537 PyObject *obj;
19538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19539 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19540 Py_INCREF(obj);
19541 return Py_BuildValue((char *)"");
19542 }
19543 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19544 PyObject *resultobj;
19545 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19546 bool arg2 = (bool) true ;
19547 int arg3 = (int) 0 ;
19548 wxActivateEvent *result;
19549 PyObject * obj0 = 0 ;
19550 PyObject * obj1 = 0 ;
19551 PyObject * obj2 = 0 ;
19552 char *kwnames[] = {
19553 (char *) "type",(char *) "active",(char *) "Id", NULL
19554 };
19555
19556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19557 if (obj0) {
19558 {
19559 arg1 = (wxEventType)(SWIG_As_int(obj0));
19560 if (SWIG_arg_fail(1)) SWIG_fail;
19561 }
19562 }
19563 if (obj1) {
19564 {
19565 arg2 = (bool)(SWIG_As_bool(obj1));
19566 if (SWIG_arg_fail(2)) SWIG_fail;
19567 }
19568 }
19569 if (obj2) {
19570 {
19571 arg3 = (int)(SWIG_As_int(obj2));
19572 if (SWIG_arg_fail(3)) SWIG_fail;
19573 }
19574 }
19575 {
19576 PyThreadState* __tstate = wxPyBeginAllowThreads();
19577 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19578
19579 wxPyEndAllowThreads(__tstate);
19580 if (PyErr_Occurred()) SWIG_fail;
19581 }
19582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19583 return resultobj;
19584 fail:
19585 return NULL;
19586 }
19587
19588
19589 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19590 PyObject *resultobj;
19591 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19592 bool result;
19593 PyObject * obj0 = 0 ;
19594 char *kwnames[] = {
19595 (char *) "self", NULL
19596 };
19597
19598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19600 if (SWIG_arg_fail(1)) SWIG_fail;
19601 {
19602 PyThreadState* __tstate = wxPyBeginAllowThreads();
19603 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19604
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 {
19609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19610 }
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19618 PyObject *obj;
19619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19620 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19621 Py_INCREF(obj);
19622 return Py_BuildValue((char *)"");
19623 }
19624 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj;
19626 int arg1 = (int) 0 ;
19627 wxInitDialogEvent *result;
19628 PyObject * obj0 = 0 ;
19629 char *kwnames[] = {
19630 (char *) "Id", NULL
19631 };
19632
19633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19634 if (obj0) {
19635 {
19636 arg1 = (int)(SWIG_As_int(obj0));
19637 if (SWIG_arg_fail(1)) SWIG_fail;
19638 }
19639 }
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19643
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19655 PyObject *obj;
19656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19657 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19658 Py_INCREF(obj);
19659 return Py_BuildValue((char *)"");
19660 }
19661 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19662 PyObject *resultobj;
19663 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19664 int arg2 = (int) 0 ;
19665 wxMenu *arg3 = (wxMenu *) NULL ;
19666 wxMenuEvent *result;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 PyObject * obj2 = 0 ;
19670 char *kwnames[] = {
19671 (char *) "type",(char *) "winid",(char *) "menu", NULL
19672 };
19673
19674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19675 if (obj0) {
19676 {
19677 arg1 = (wxEventType)(SWIG_As_int(obj0));
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 }
19680 }
19681 if (obj1) {
19682 {
19683 arg2 = (int)(SWIG_As_int(obj1));
19684 if (SWIG_arg_fail(2)) SWIG_fail;
19685 }
19686 }
19687 if (obj2) {
19688 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19689 if (SWIG_arg_fail(3)) SWIG_fail;
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19694
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj;
19707 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19708 int result;
19709 PyObject * obj0 = 0 ;
19710 char *kwnames[] = {
19711 (char *) "self", NULL
19712 };
19713
19714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19716 if (SWIG_arg_fail(1)) SWIG_fail;
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19720
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 {
19725 resultobj = SWIG_From_int((int)(result));
19726 }
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19734 PyObject *resultobj;
19735 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19736 bool result;
19737 PyObject * obj0 = 0 ;
19738 char *kwnames[] = {
19739 (char *) "self", NULL
19740 };
19741
19742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19744 if (SWIG_arg_fail(1)) SWIG_fail;
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 {
19753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19764 wxMenu *result;
19765 PyObject * obj0 = 0 ;
19766 char *kwnames[] = {
19767 (char *) "self", NULL
19768 };
19769
19770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19772 if (SWIG_arg_fail(1)) SWIG_fail;
19773 {
19774 PyThreadState* __tstate = wxPyBeginAllowThreads();
19775 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19776
19777 wxPyEndAllowThreads(__tstate);
19778 if (PyErr_Occurred()) SWIG_fail;
19779 }
19780 {
19781 resultobj = wxPyMake_wxObject(result, 0);
19782 }
19783 return resultobj;
19784 fail:
19785 return NULL;
19786 }
19787
19788
19789 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19790 PyObject *obj;
19791 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19792 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19793 Py_INCREF(obj);
19794 return Py_BuildValue((char *)"");
19795 }
19796 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj;
19798 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19799 int arg2 = (int) 0 ;
19800 wxCloseEvent *result;
19801 PyObject * obj0 = 0 ;
19802 PyObject * obj1 = 0 ;
19803 char *kwnames[] = {
19804 (char *) "type",(char *) "winid", NULL
19805 };
19806
19807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19808 if (obj0) {
19809 {
19810 arg1 = (wxEventType)(SWIG_As_int(obj0));
19811 if (SWIG_arg_fail(1)) SWIG_fail;
19812 }
19813 }
19814 if (obj1) {
19815 {
19816 arg2 = (int)(SWIG_As_int(obj1));
19817 if (SWIG_arg_fail(2)) SWIG_fail;
19818 }
19819 }
19820 {
19821 PyThreadState* __tstate = wxPyBeginAllowThreads();
19822 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19823
19824 wxPyEndAllowThreads(__tstate);
19825 if (PyErr_Occurred()) SWIG_fail;
19826 }
19827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19828 return resultobj;
19829 fail:
19830 return NULL;
19831 }
19832
19833
19834 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19835 PyObject *resultobj;
19836 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19837 bool arg2 ;
19838 PyObject * obj0 = 0 ;
19839 PyObject * obj1 = 0 ;
19840 char *kwnames[] = {
19841 (char *) "self",(char *) "logOff", NULL
19842 };
19843
19844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19846 if (SWIG_arg_fail(1)) SWIG_fail;
19847 {
19848 arg2 = (bool)(SWIG_As_bool(obj1));
19849 if (SWIG_arg_fail(2)) SWIG_fail;
19850 }
19851 {
19852 PyThreadState* __tstate = wxPyBeginAllowThreads();
19853 (arg1)->SetLoggingOff(arg2);
19854
19855 wxPyEndAllowThreads(__tstate);
19856 if (PyErr_Occurred()) SWIG_fail;
19857 }
19858 Py_INCREF(Py_None); resultobj = Py_None;
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj;
19867 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19868 bool result;
19869 PyObject * obj0 = 0 ;
19870 char *kwnames[] = {
19871 (char *) "self", NULL
19872 };
19873
19874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19876 if (SWIG_arg_fail(1)) SWIG_fail;
19877 {
19878 PyThreadState* __tstate = wxPyBeginAllowThreads();
19879 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19880
19881 wxPyEndAllowThreads(__tstate);
19882 if (PyErr_Occurred()) SWIG_fail;
19883 }
19884 {
19885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19886 }
19887 return resultobj;
19888 fail:
19889 return NULL;
19890 }
19891
19892
19893 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19894 PyObject *resultobj;
19895 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19896 bool arg2 = (bool) true ;
19897 PyObject * obj0 = 0 ;
19898 PyObject * obj1 = 0 ;
19899 char *kwnames[] = {
19900 (char *) "self",(char *) "veto", NULL
19901 };
19902
19903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19905 if (SWIG_arg_fail(1)) SWIG_fail;
19906 if (obj1) {
19907 {
19908 arg2 = (bool)(SWIG_As_bool(obj1));
19909 if (SWIG_arg_fail(2)) SWIG_fail;
19910 }
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 (arg1)->Veto(arg2);
19915
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 Py_INCREF(Py_None); resultobj = Py_None;
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj;
19928 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19929 bool arg2 ;
19930 PyObject * obj0 = 0 ;
19931 PyObject * obj1 = 0 ;
19932 char *kwnames[] = {
19933 (char *) "self",(char *) "canVeto", NULL
19934 };
19935
19936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19938 if (SWIG_arg_fail(1)) SWIG_fail;
19939 {
19940 arg2 = (bool)(SWIG_As_bool(obj1));
19941 if (SWIG_arg_fail(2)) SWIG_fail;
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 (arg1)->SetCanVeto(arg2);
19946
19947 wxPyEndAllowThreads(__tstate);
19948 if (PyErr_Occurred()) SWIG_fail;
19949 }
19950 Py_INCREF(Py_None); resultobj = Py_None;
19951 return resultobj;
19952 fail:
19953 return NULL;
19954 }
19955
19956
19957 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19958 PyObject *resultobj;
19959 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19960 bool result;
19961 PyObject * obj0 = 0 ;
19962 char *kwnames[] = {
19963 (char *) "self", NULL
19964 };
19965
19966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19968 if (SWIG_arg_fail(1)) SWIG_fail;
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19972
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 {
19977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19978 }
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19986 PyObject *resultobj;
19987 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19988 bool result;
19989 PyObject * obj0 = 0 ;
19990 char *kwnames[] = {
19991 (char *) "self", NULL
19992 };
19993
19994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19996 if (SWIG_arg_fail(1)) SWIG_fail;
19997 {
19998 PyThreadState* __tstate = wxPyBeginAllowThreads();
19999 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20000
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 {
20005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20006 }
20007 return resultobj;
20008 fail:
20009 return NULL;
20010 }
20011
20012
20013 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20014 PyObject *obj;
20015 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20016 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20017 Py_INCREF(obj);
20018 return Py_BuildValue((char *)"");
20019 }
20020 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj;
20022 int arg1 = (int) 0 ;
20023 bool arg2 = (bool) false ;
20024 wxShowEvent *result;
20025 PyObject * obj0 = 0 ;
20026 PyObject * obj1 = 0 ;
20027 char *kwnames[] = {
20028 (char *) "winid",(char *) "show", NULL
20029 };
20030
20031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20032 if (obj0) {
20033 {
20034 arg1 = (int)(SWIG_As_int(obj0));
20035 if (SWIG_arg_fail(1)) SWIG_fail;
20036 }
20037 }
20038 if (obj1) {
20039 {
20040 arg2 = (bool)(SWIG_As_bool(obj1));
20041 if (SWIG_arg_fail(2)) SWIG_fail;
20042 }
20043 }
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj;
20060 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20061 bool arg2 ;
20062 PyObject * obj0 = 0 ;
20063 PyObject * obj1 = 0 ;
20064 char *kwnames[] = {
20065 (char *) "self",(char *) "show", NULL
20066 };
20067
20068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20070 if (SWIG_arg_fail(1)) SWIG_fail;
20071 {
20072 arg2 = (bool)(SWIG_As_bool(obj1));
20073 if (SWIG_arg_fail(2)) SWIG_fail;
20074 }
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 (arg1)->SetShow(arg2);
20078
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 Py_INCREF(Py_None); resultobj = Py_None;
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20090 PyObject *resultobj;
20091 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20092 bool result;
20093 PyObject * obj0 = 0 ;
20094 char *kwnames[] = {
20095 (char *) "self", NULL
20096 };
20097
20098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20100 if (SWIG_arg_fail(1)) SWIG_fail;
20101 {
20102 PyThreadState* __tstate = wxPyBeginAllowThreads();
20103 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20104
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20118 PyObject *obj;
20119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20120 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20121 Py_INCREF(obj);
20122 return Py_BuildValue((char *)"");
20123 }
20124 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20125 PyObject *resultobj;
20126 int arg1 = (int) 0 ;
20127 bool arg2 = (bool) true ;
20128 wxIconizeEvent *result;
20129 PyObject * obj0 = 0 ;
20130 PyObject * obj1 = 0 ;
20131 char *kwnames[] = {
20132 (char *) "id",(char *) "iconized", NULL
20133 };
20134
20135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20136 if (obj0) {
20137 {
20138 arg1 = (int)(SWIG_As_int(obj0));
20139 if (SWIG_arg_fail(1)) SWIG_fail;
20140 }
20141 }
20142 if (obj1) {
20143 {
20144 arg2 = (bool)(SWIG_As_bool(obj1));
20145 if (SWIG_arg_fail(2)) SWIG_fail;
20146 }
20147 }
20148 {
20149 PyThreadState* __tstate = wxPyBeginAllowThreads();
20150 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20151
20152 wxPyEndAllowThreads(__tstate);
20153 if (PyErr_Occurred()) SWIG_fail;
20154 }
20155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20156 return resultobj;
20157 fail:
20158 return NULL;
20159 }
20160
20161
20162 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20163 PyObject *resultobj;
20164 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20165 bool result;
20166 PyObject * obj0 = 0 ;
20167 char *kwnames[] = {
20168 (char *) "self", NULL
20169 };
20170
20171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20173 if (SWIG_arg_fail(1)) SWIG_fail;
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 result = (bool)(arg1)->Iconized();
20177
20178 wxPyEndAllowThreads(__tstate);
20179 if (PyErr_Occurred()) SWIG_fail;
20180 }
20181 {
20182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20183 }
20184 return resultobj;
20185 fail:
20186 return NULL;
20187 }
20188
20189
20190 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20191 PyObject *obj;
20192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20193 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20194 Py_INCREF(obj);
20195 return Py_BuildValue((char *)"");
20196 }
20197 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20198 PyObject *resultobj;
20199 int arg1 = (int) 0 ;
20200 wxMaximizeEvent *result;
20201 PyObject * obj0 = 0 ;
20202 char *kwnames[] = {
20203 (char *) "id", NULL
20204 };
20205
20206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20207 if (obj0) {
20208 {
20209 arg1 = (int)(SWIG_As_int(obj0));
20210 if (SWIG_arg_fail(1)) SWIG_fail;
20211 }
20212 }
20213 {
20214 PyThreadState* __tstate = wxPyBeginAllowThreads();
20215 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20216
20217 wxPyEndAllowThreads(__tstate);
20218 if (PyErr_Occurred()) SWIG_fail;
20219 }
20220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20221 return resultobj;
20222 fail:
20223 return NULL;
20224 }
20225
20226
20227 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20228 PyObject *obj;
20229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20230 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20231 Py_INCREF(obj);
20232 return Py_BuildValue((char *)"");
20233 }
20234 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20235 PyObject *resultobj;
20236 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20237 wxPoint result;
20238 PyObject * obj0 = 0 ;
20239 char *kwnames[] = {
20240 (char *) "self", NULL
20241 };
20242
20243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20245 if (SWIG_arg_fail(1)) SWIG_fail;
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (arg1)->GetPosition();
20249
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 {
20254 wxPoint * resultptr;
20255 resultptr = new wxPoint((wxPoint &)(result));
20256 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20265 PyObject *resultobj;
20266 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20267 int result;
20268 PyObject * obj0 = 0 ;
20269 char *kwnames[] = {
20270 (char *) "self", NULL
20271 };
20272
20273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20275 if (SWIG_arg_fail(1)) SWIG_fail;
20276 {
20277 PyThreadState* __tstate = wxPyBeginAllowThreads();
20278 result = (int)(arg1)->GetNumberOfFiles();
20279
20280 wxPyEndAllowThreads(__tstate);
20281 if (PyErr_Occurred()) SWIG_fail;
20282 }
20283 {
20284 resultobj = SWIG_From_int((int)(result));
20285 }
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20293 PyObject *resultobj;
20294 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20295 PyObject *result;
20296 PyObject * obj0 = 0 ;
20297 char *kwnames[] = {
20298 (char *) "self", NULL
20299 };
20300
20301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20303 if (SWIG_arg_fail(1)) SWIG_fail;
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20307
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = result;
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20319 PyObject *obj;
20320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20321 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20322 Py_INCREF(obj);
20323 return Py_BuildValue((char *)"");
20324 }
20325 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20326 PyObject *resultobj;
20327 int arg1 = (int) 0 ;
20328 wxUpdateUIEvent *result;
20329 PyObject * obj0 = 0 ;
20330 char *kwnames[] = {
20331 (char *) "commandId", NULL
20332 };
20333
20334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20335 if (obj0) {
20336 {
20337 arg1 = (int)(SWIG_As_int(obj0));
20338 if (SWIG_arg_fail(1)) SWIG_fail;
20339 }
20340 }
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20344
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20356 PyObject *resultobj;
20357 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20358 bool result;
20359 PyObject * obj0 = 0 ;
20360 char *kwnames[] = {
20361 (char *) "self", NULL
20362 };
20363
20364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20366 if (SWIG_arg_fail(1)) SWIG_fail;
20367 {
20368 PyThreadState* __tstate = wxPyBeginAllowThreads();
20369 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20370
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 {
20375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20376 }
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20384 PyObject *resultobj;
20385 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20386 bool result;
20387 PyObject * obj0 = 0 ;
20388 char *kwnames[] = {
20389 (char *) "self", NULL
20390 };
20391
20392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20394 if (SWIG_arg_fail(1)) SWIG_fail;
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20398
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 {
20403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20404 }
20405 return resultobj;
20406 fail:
20407 return NULL;
20408 }
20409
20410
20411 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20412 PyObject *resultobj;
20413 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20414 wxString result;
20415 PyObject * obj0 = 0 ;
20416 char *kwnames[] = {
20417 (char *) "self", NULL
20418 };
20419
20420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20422 if (SWIG_arg_fail(1)) SWIG_fail;
20423 {
20424 PyThreadState* __tstate = wxPyBeginAllowThreads();
20425 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20426
20427 wxPyEndAllowThreads(__tstate);
20428 if (PyErr_Occurred()) SWIG_fail;
20429 }
20430 {
20431 #if wxUSE_UNICODE
20432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20433 #else
20434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20435 #endif
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj;
20445 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20446 bool result;
20447 PyObject * obj0 = 0 ;
20448 char *kwnames[] = {
20449 (char *) "self", NULL
20450 };
20451
20452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20454 if (SWIG_arg_fail(1)) SWIG_fail;
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20464 }
20465 return resultobj;
20466 fail:
20467 return NULL;
20468 }
20469
20470
20471 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20472 PyObject *resultobj;
20473 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20474 bool result;
20475 PyObject * obj0 = 0 ;
20476 char *kwnames[] = {
20477 (char *) "self", NULL
20478 };
20479
20480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20482 if (SWIG_arg_fail(1)) SWIG_fail;
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20486
20487 wxPyEndAllowThreads(__tstate);
20488 if (PyErr_Occurred()) SWIG_fail;
20489 }
20490 {
20491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20492 }
20493 return resultobj;
20494 fail:
20495 return NULL;
20496 }
20497
20498
20499 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20500 PyObject *resultobj;
20501 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20502 bool result;
20503 PyObject * obj0 = 0 ;
20504 char *kwnames[] = {
20505 (char *) "self", NULL
20506 };
20507
20508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20510 if (SWIG_arg_fail(1)) SWIG_fail;
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20514
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 {
20519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20520 }
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj;
20529 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20530 bool arg2 ;
20531 PyObject * obj0 = 0 ;
20532 PyObject * obj1 = 0 ;
20533 char *kwnames[] = {
20534 (char *) "self",(char *) "check", NULL
20535 };
20536
20537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20539 if (SWIG_arg_fail(1)) SWIG_fail;
20540 {
20541 arg2 = (bool)(SWIG_As_bool(obj1));
20542 if (SWIG_arg_fail(2)) SWIG_fail;
20543 }
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 (arg1)->Check(arg2);
20547
20548 wxPyEndAllowThreads(__tstate);
20549 if (PyErr_Occurred()) SWIG_fail;
20550 }
20551 Py_INCREF(Py_None); resultobj = Py_None;
20552 return resultobj;
20553 fail:
20554 return NULL;
20555 }
20556
20557
20558 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20559 PyObject *resultobj;
20560 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20561 bool arg2 ;
20562 PyObject * obj0 = 0 ;
20563 PyObject * obj1 = 0 ;
20564 char *kwnames[] = {
20565 (char *) "self",(char *) "enable", NULL
20566 };
20567
20568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20570 if (SWIG_arg_fail(1)) SWIG_fail;
20571 {
20572 arg2 = (bool)(SWIG_As_bool(obj1));
20573 if (SWIG_arg_fail(2)) SWIG_fail;
20574 }
20575 {
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 (arg1)->Enable(arg2);
20578
20579 wxPyEndAllowThreads(__tstate);
20580 if (PyErr_Occurred()) SWIG_fail;
20581 }
20582 Py_INCREF(Py_None); resultobj = Py_None;
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20590 PyObject *resultobj;
20591 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20592 wxString *arg2 = 0 ;
20593 bool temp2 = false ;
20594 PyObject * obj0 = 0 ;
20595 PyObject * obj1 = 0 ;
20596 char *kwnames[] = {
20597 (char *) "self",(char *) "text", NULL
20598 };
20599
20600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20602 if (SWIG_arg_fail(1)) SWIG_fail;
20603 {
20604 arg2 = wxString_in_helper(obj1);
20605 if (arg2 == NULL) SWIG_fail;
20606 temp2 = true;
20607 }
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 (arg1)->SetText((wxString const &)*arg2);
20611
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 Py_INCREF(Py_None); resultobj = Py_None;
20616 {
20617 if (temp2)
20618 delete arg2;
20619 }
20620 return resultobj;
20621 fail:
20622 {
20623 if (temp2)
20624 delete arg2;
20625 }
20626 return NULL;
20627 }
20628
20629
20630 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20631 PyObject *resultobj;
20632 long arg1 ;
20633 PyObject * obj0 = 0 ;
20634 char *kwnames[] = {
20635 (char *) "updateInterval", NULL
20636 };
20637
20638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20639 {
20640 arg1 = (long)(SWIG_As_long(obj0));
20641 if (SWIG_arg_fail(1)) SWIG_fail;
20642 }
20643 {
20644 PyThreadState* __tstate = wxPyBeginAllowThreads();
20645 wxUpdateUIEvent::SetUpdateInterval(arg1);
20646
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 Py_INCREF(Py_None); resultobj = Py_None;
20651 return resultobj;
20652 fail:
20653 return NULL;
20654 }
20655
20656
20657 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20658 PyObject *resultobj;
20659 long result;
20660 char *kwnames[] = {
20661 NULL
20662 };
20663
20664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20665 {
20666 PyThreadState* __tstate = wxPyBeginAllowThreads();
20667 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20668
20669 wxPyEndAllowThreads(__tstate);
20670 if (PyErr_Occurred()) SWIG_fail;
20671 }
20672 {
20673 resultobj = SWIG_From_long((long)(result));
20674 }
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20682 PyObject *resultobj;
20683 wxWindow *arg1 = (wxWindow *) 0 ;
20684 bool result;
20685 PyObject * obj0 = 0 ;
20686 char *kwnames[] = {
20687 (char *) "win", NULL
20688 };
20689
20690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20692 if (SWIG_arg_fail(1)) SWIG_fail;
20693 {
20694 PyThreadState* __tstate = wxPyBeginAllowThreads();
20695 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20696
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 {
20701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20702 }
20703 return resultobj;
20704 fail:
20705 return NULL;
20706 }
20707
20708
20709 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20710 PyObject *resultobj;
20711 char *kwnames[] = {
20712 NULL
20713 };
20714
20715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20716 {
20717 PyThreadState* __tstate = wxPyBeginAllowThreads();
20718 wxUpdateUIEvent::ResetUpdateTime();
20719
20720 wxPyEndAllowThreads(__tstate);
20721 if (PyErr_Occurred()) SWIG_fail;
20722 }
20723 Py_INCREF(Py_None); resultobj = Py_None;
20724 return resultobj;
20725 fail:
20726 return NULL;
20727 }
20728
20729
20730 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20731 PyObject *resultobj;
20732 wxUpdateUIMode arg1 ;
20733 PyObject * obj0 = 0 ;
20734 char *kwnames[] = {
20735 (char *) "mode", NULL
20736 };
20737
20738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20739 {
20740 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20741 if (SWIG_arg_fail(1)) SWIG_fail;
20742 }
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20746
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 Py_INCREF(Py_None); resultobj = Py_None;
20751 return resultobj;
20752 fail:
20753 return NULL;
20754 }
20755
20756
20757 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20758 PyObject *resultobj;
20759 wxUpdateUIMode result;
20760 char *kwnames[] = {
20761 NULL
20762 };
20763
20764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20768
20769 wxPyEndAllowThreads(__tstate);
20770 if (PyErr_Occurred()) SWIG_fail;
20771 }
20772 resultobj = SWIG_From_int((result));
20773 return resultobj;
20774 fail:
20775 return NULL;
20776 }
20777
20778
20779 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20780 PyObject *obj;
20781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20782 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20783 Py_INCREF(obj);
20784 return Py_BuildValue((char *)"");
20785 }
20786 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj;
20788 wxSysColourChangedEvent *result;
20789 char *kwnames[] = {
20790 NULL
20791 };
20792
20793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20797
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20809 PyObject *obj;
20810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20811 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20812 Py_INCREF(obj);
20813 return Py_BuildValue((char *)"");
20814 }
20815 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20816 PyObject *resultobj;
20817 int arg1 = (int) 0 ;
20818 wxWindow *arg2 = (wxWindow *) NULL ;
20819 wxMouseCaptureChangedEvent *result;
20820 PyObject * obj0 = 0 ;
20821 PyObject * obj1 = 0 ;
20822 char *kwnames[] = {
20823 (char *) "winid",(char *) "gainedCapture", NULL
20824 };
20825
20826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20827 if (obj0) {
20828 {
20829 arg1 = (int)(SWIG_As_int(obj0));
20830 if (SWIG_arg_fail(1)) SWIG_fail;
20831 }
20832 }
20833 if (obj1) {
20834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20835 if (SWIG_arg_fail(2)) SWIG_fail;
20836 }
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20840
20841 wxPyEndAllowThreads(__tstate);
20842 if (PyErr_Occurred()) SWIG_fail;
20843 }
20844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20845 return resultobj;
20846 fail:
20847 return NULL;
20848 }
20849
20850
20851 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20852 PyObject *resultobj;
20853 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20854 wxWindow *result;
20855 PyObject * obj0 = 0 ;
20856 char *kwnames[] = {
20857 (char *) "self", NULL
20858 };
20859
20860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20862 if (SWIG_arg_fail(1)) SWIG_fail;
20863 {
20864 PyThreadState* __tstate = wxPyBeginAllowThreads();
20865 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20866
20867 wxPyEndAllowThreads(__tstate);
20868 if (PyErr_Occurred()) SWIG_fail;
20869 }
20870 {
20871 resultobj = wxPyMake_wxObject(result, 0);
20872 }
20873 return resultobj;
20874 fail:
20875 return NULL;
20876 }
20877
20878
20879 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20880 PyObject *obj;
20881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20882 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20883 Py_INCREF(obj);
20884 return Py_BuildValue((char *)"");
20885 }
20886 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj;
20888 wxDisplayChangedEvent *result;
20889 char *kwnames[] = {
20890 NULL
20891 };
20892
20893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20894 {
20895 PyThreadState* __tstate = wxPyBeginAllowThreads();
20896 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20897
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20902 return resultobj;
20903 fail:
20904 return NULL;
20905 }
20906
20907
20908 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20909 PyObject *obj;
20910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20911 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20912 Py_INCREF(obj);
20913 return Py_BuildValue((char *)"");
20914 }
20915 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20916 PyObject *resultobj;
20917 int arg1 = (int) 0 ;
20918 wxPaletteChangedEvent *result;
20919 PyObject * obj0 = 0 ;
20920 char *kwnames[] = {
20921 (char *) "id", NULL
20922 };
20923
20924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20925 if (obj0) {
20926 {
20927 arg1 = (int)(SWIG_As_int(obj0));
20928 if (SWIG_arg_fail(1)) SWIG_fail;
20929 }
20930 }
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20934
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20939 return resultobj;
20940 fail:
20941 return NULL;
20942 }
20943
20944
20945 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20946 PyObject *resultobj;
20947 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20948 wxWindow *arg2 = (wxWindow *) 0 ;
20949 PyObject * obj0 = 0 ;
20950 PyObject * obj1 = 0 ;
20951 char *kwnames[] = {
20952 (char *) "self",(char *) "win", NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20957 if (SWIG_arg_fail(1)) SWIG_fail;
20958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20959 if (SWIG_arg_fail(2)) SWIG_fail;
20960 {
20961 PyThreadState* __tstate = wxPyBeginAllowThreads();
20962 (arg1)->SetChangedWindow(arg2);
20963
20964 wxPyEndAllowThreads(__tstate);
20965 if (PyErr_Occurred()) SWIG_fail;
20966 }
20967 Py_INCREF(Py_None); resultobj = Py_None;
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20975 PyObject *resultobj;
20976 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20977 wxWindow *result;
20978 PyObject * obj0 = 0 ;
20979 char *kwnames[] = {
20980 (char *) "self", NULL
20981 };
20982
20983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20985 if (SWIG_arg_fail(1)) SWIG_fail;
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (wxWindow *)(arg1)->GetChangedWindow();
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = wxPyMake_wxObject(result, 0);
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21003 PyObject *obj;
21004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21005 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21006 Py_INCREF(obj);
21007 return Py_BuildValue((char *)"");
21008 }
21009 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj;
21011 int arg1 = (int) 0 ;
21012 wxQueryNewPaletteEvent *result;
21013 PyObject * obj0 = 0 ;
21014 char *kwnames[] = {
21015 (char *) "winid", NULL
21016 };
21017
21018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21019 if (obj0) {
21020 {
21021 arg1 = (int)(SWIG_As_int(obj0));
21022 if (SWIG_arg_fail(1)) SWIG_fail;
21023 }
21024 }
21025 {
21026 PyThreadState* __tstate = wxPyBeginAllowThreads();
21027 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21028
21029 wxPyEndAllowThreads(__tstate);
21030 if (PyErr_Occurred()) SWIG_fail;
21031 }
21032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21033 return resultobj;
21034 fail:
21035 return NULL;
21036 }
21037
21038
21039 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21040 PyObject *resultobj;
21041 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21042 bool arg2 ;
21043 PyObject * obj0 = 0 ;
21044 PyObject * obj1 = 0 ;
21045 char *kwnames[] = {
21046 (char *) "self",(char *) "realized", NULL
21047 };
21048
21049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21051 if (SWIG_arg_fail(1)) SWIG_fail;
21052 {
21053 arg2 = (bool)(SWIG_As_bool(obj1));
21054 if (SWIG_arg_fail(2)) SWIG_fail;
21055 }
21056 {
21057 PyThreadState* __tstate = wxPyBeginAllowThreads();
21058 (arg1)->SetPaletteRealized(arg2);
21059
21060 wxPyEndAllowThreads(__tstate);
21061 if (PyErr_Occurred()) SWIG_fail;
21062 }
21063 Py_INCREF(Py_None); resultobj = Py_None;
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21071 PyObject *resultobj;
21072 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21073 bool result;
21074 PyObject * obj0 = 0 ;
21075 char *kwnames[] = {
21076 (char *) "self", NULL
21077 };
21078
21079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21081 if (SWIG_arg_fail(1)) SWIG_fail;
21082 {
21083 PyThreadState* __tstate = wxPyBeginAllowThreads();
21084 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21085
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 {
21090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21099 PyObject *obj;
21100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21101 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21102 Py_INCREF(obj);
21103 return Py_BuildValue((char *)"");
21104 }
21105 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj;
21107 wxNavigationKeyEvent *result;
21108 char *kwnames[] = {
21109 NULL
21110 };
21111
21112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21116
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21128 PyObject *resultobj;
21129 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21130 bool result;
21131 PyObject * obj0 = 0 ;
21132 char *kwnames[] = {
21133 (char *) "self", NULL
21134 };
21135
21136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21138 if (SWIG_arg_fail(1)) SWIG_fail;
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21142
21143 wxPyEndAllowThreads(__tstate);
21144 if (PyErr_Occurred()) SWIG_fail;
21145 }
21146 {
21147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21148 }
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21156 PyObject *resultobj;
21157 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21158 bool arg2 ;
21159 PyObject * obj0 = 0 ;
21160 PyObject * obj1 = 0 ;
21161 char *kwnames[] = {
21162 (char *) "self",(char *) "forward", NULL
21163 };
21164
21165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21167 if (SWIG_arg_fail(1)) SWIG_fail;
21168 {
21169 arg2 = (bool)(SWIG_As_bool(obj1));
21170 if (SWIG_arg_fail(2)) SWIG_fail;
21171 }
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 (arg1)->SetDirection(arg2);
21175
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 Py_INCREF(Py_None); resultobj = Py_None;
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj;
21188 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21189 bool result;
21190 PyObject * obj0 = 0 ;
21191 char *kwnames[] = {
21192 (char *) "self", NULL
21193 };
21194
21195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21197 if (SWIG_arg_fail(1)) SWIG_fail;
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21201
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 {
21206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21207 }
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21215 PyObject *resultobj;
21216 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21217 bool arg2 ;
21218 PyObject * obj0 = 0 ;
21219 PyObject * obj1 = 0 ;
21220 char *kwnames[] = {
21221 (char *) "self",(char *) "ischange", NULL
21222 };
21223
21224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21226 if (SWIG_arg_fail(1)) SWIG_fail;
21227 {
21228 arg2 = (bool)(SWIG_As_bool(obj1));
21229 if (SWIG_arg_fail(2)) SWIG_fail;
21230 }
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 (arg1)->SetWindowChange(arg2);
21234
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 Py_INCREF(Py_None); resultobj = Py_None;
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21246 PyObject *resultobj;
21247 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21248 bool result;
21249 PyObject * obj0 = 0 ;
21250 char *kwnames[] = {
21251 (char *) "self", NULL
21252 };
21253
21254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21256 if (SWIG_arg_fail(1)) SWIG_fail;
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21260
21261 wxPyEndAllowThreads(__tstate);
21262 if (PyErr_Occurred()) SWIG_fail;
21263 }
21264 {
21265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21266 }
21267 return resultobj;
21268 fail:
21269 return NULL;
21270 }
21271
21272
21273 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21274 PyObject *resultobj;
21275 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21276 bool arg2 ;
21277 PyObject * obj0 = 0 ;
21278 PyObject * obj1 = 0 ;
21279 char *kwnames[] = {
21280 (char *) "self",(char *) "bIs", NULL
21281 };
21282
21283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21285 if (SWIG_arg_fail(1)) SWIG_fail;
21286 {
21287 arg2 = (bool)(SWIG_As_bool(obj1));
21288 if (SWIG_arg_fail(2)) SWIG_fail;
21289 }
21290 {
21291 PyThreadState* __tstate = wxPyBeginAllowThreads();
21292 (arg1)->SetFromTab(arg2);
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 Py_INCREF(Py_None); resultobj = Py_None;
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj;
21306 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21307 long arg2 ;
21308 PyObject * obj0 = 0 ;
21309 PyObject * obj1 = 0 ;
21310 char *kwnames[] = {
21311 (char *) "self",(char *) "flags", NULL
21312 };
21313
21314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21316 if (SWIG_arg_fail(1)) SWIG_fail;
21317 {
21318 arg2 = (long)(SWIG_As_long(obj1));
21319 if (SWIG_arg_fail(2)) SWIG_fail;
21320 }
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 (arg1)->SetFlags(arg2);
21324
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 Py_INCREF(Py_None); resultobj = Py_None;
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21336 PyObject *resultobj;
21337 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21338 wxWindow *result;
21339 PyObject * obj0 = 0 ;
21340 char *kwnames[] = {
21341 (char *) "self", NULL
21342 };
21343
21344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21346 if (SWIG_arg_fail(1)) SWIG_fail;
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21350
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 {
21355 resultobj = wxPyMake_wxObject(result, 0);
21356 }
21357 return resultobj;
21358 fail:
21359 return NULL;
21360 }
21361
21362
21363 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21364 PyObject *resultobj;
21365 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21366 wxWindow *arg2 = (wxWindow *) 0 ;
21367 PyObject * obj0 = 0 ;
21368 PyObject * obj1 = 0 ;
21369 char *kwnames[] = {
21370 (char *) "self",(char *) "win", NULL
21371 };
21372
21373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21375 if (SWIG_arg_fail(1)) SWIG_fail;
21376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21377 if (SWIG_arg_fail(2)) SWIG_fail;
21378 {
21379 PyThreadState* __tstate = wxPyBeginAllowThreads();
21380 (arg1)->SetCurrentFocus(arg2);
21381
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 Py_INCREF(Py_None); resultobj = Py_None;
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21393 PyObject *obj;
21394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21395 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21396 Py_INCREF(obj);
21397 return Py_BuildValue((char *)"");
21398 }
21399 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21400 PyObject *resultobj;
21401 wxWindow *arg1 = (wxWindow *) NULL ;
21402 wxWindowCreateEvent *result;
21403 PyObject * obj0 = 0 ;
21404 char *kwnames[] = {
21405 (char *) "win", NULL
21406 };
21407
21408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21409 if (obj0) {
21410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21411 if (SWIG_arg_fail(1)) SWIG_fail;
21412 }
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21416
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj;
21429 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21430 wxWindow *result;
21431 PyObject * obj0 = 0 ;
21432 char *kwnames[] = {
21433 (char *) "self", NULL
21434 };
21435
21436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21438 if (SWIG_arg_fail(1)) SWIG_fail;
21439 {
21440 PyThreadState* __tstate = wxPyBeginAllowThreads();
21441 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21442
21443 wxPyEndAllowThreads(__tstate);
21444 if (PyErr_Occurred()) SWIG_fail;
21445 }
21446 {
21447 resultobj = wxPyMake_wxObject(result, 0);
21448 }
21449 return resultobj;
21450 fail:
21451 return NULL;
21452 }
21453
21454
21455 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21456 PyObject *obj;
21457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21458 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21459 Py_INCREF(obj);
21460 return Py_BuildValue((char *)"");
21461 }
21462 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj;
21464 wxWindow *arg1 = (wxWindow *) NULL ;
21465 wxWindowDestroyEvent *result;
21466 PyObject * obj0 = 0 ;
21467 char *kwnames[] = {
21468 (char *) "win", NULL
21469 };
21470
21471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21472 if (obj0) {
21473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21474 if (SWIG_arg_fail(1)) SWIG_fail;
21475 }
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21479
21480 wxPyEndAllowThreads(__tstate);
21481 if (PyErr_Occurred()) SWIG_fail;
21482 }
21483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21484 return resultobj;
21485 fail:
21486 return NULL;
21487 }
21488
21489
21490 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21491 PyObject *resultobj;
21492 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21493 wxWindow *result;
21494 PyObject * obj0 = 0 ;
21495 char *kwnames[] = {
21496 (char *) "self", NULL
21497 };
21498
21499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21501 if (SWIG_arg_fail(1)) SWIG_fail;
21502 {
21503 PyThreadState* __tstate = wxPyBeginAllowThreads();
21504 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21505
21506 wxPyEndAllowThreads(__tstate);
21507 if (PyErr_Occurred()) SWIG_fail;
21508 }
21509 {
21510 resultobj = wxPyMake_wxObject(result, 0);
21511 }
21512 return resultobj;
21513 fail:
21514 return NULL;
21515 }
21516
21517
21518 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21519 PyObject *obj;
21520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21521 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21522 Py_INCREF(obj);
21523 return Py_BuildValue((char *)"");
21524 }
21525 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21526 PyObject *resultobj;
21527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21528 int arg2 = (int) 0 ;
21529 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21530 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21531 wxContextMenuEvent *result;
21532 wxPoint temp3 ;
21533 PyObject * obj0 = 0 ;
21534 PyObject * obj1 = 0 ;
21535 PyObject * obj2 = 0 ;
21536 char *kwnames[] = {
21537 (char *) "type",(char *) "winid",(char *) "pt", NULL
21538 };
21539
21540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21541 if (obj0) {
21542 {
21543 arg1 = (wxEventType)(SWIG_As_int(obj0));
21544 if (SWIG_arg_fail(1)) SWIG_fail;
21545 }
21546 }
21547 if (obj1) {
21548 {
21549 arg2 = (int)(SWIG_As_int(obj1));
21550 if (SWIG_arg_fail(2)) SWIG_fail;
21551 }
21552 }
21553 if (obj2) {
21554 {
21555 arg3 = &temp3;
21556 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21557 }
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21562
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21574 PyObject *resultobj;
21575 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21576 wxPoint *result;
21577 PyObject * obj0 = 0 ;
21578 char *kwnames[] = {
21579 (char *) "self", NULL
21580 };
21581
21582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21584 if (SWIG_arg_fail(1)) SWIG_fail;
21585 {
21586 PyThreadState* __tstate = wxPyBeginAllowThreads();
21587 {
21588 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21589 result = (wxPoint *) &_result_ref;
21590 }
21591
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21603 PyObject *resultobj;
21604 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21605 wxPoint *arg2 = 0 ;
21606 wxPoint temp2 ;
21607 PyObject * obj0 = 0 ;
21608 PyObject * obj1 = 0 ;
21609 char *kwnames[] = {
21610 (char *) "self",(char *) "pos", NULL
21611 };
21612
21613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21615 if (SWIG_arg_fail(1)) SWIG_fail;
21616 {
21617 arg2 = &temp2;
21618 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21619 }
21620 {
21621 PyThreadState* __tstate = wxPyBeginAllowThreads();
21622 (arg1)->SetPosition((wxPoint const &)*arg2);
21623
21624 wxPyEndAllowThreads(__tstate);
21625 if (PyErr_Occurred()) SWIG_fail;
21626 }
21627 Py_INCREF(Py_None); resultobj = Py_None;
21628 return resultobj;
21629 fail:
21630 return NULL;
21631 }
21632
21633
21634 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21635 PyObject *obj;
21636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21637 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21638 Py_INCREF(obj);
21639 return Py_BuildValue((char *)"");
21640 }
21641 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj;
21643 wxIdleEvent *result;
21644 char *kwnames[] = {
21645 NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21649 {
21650 PyThreadState* __tstate = wxPyBeginAllowThreads();
21651 result = (wxIdleEvent *)new wxIdleEvent();
21652
21653 wxPyEndAllowThreads(__tstate);
21654 if (PyErr_Occurred()) SWIG_fail;
21655 }
21656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21657 return resultobj;
21658 fail:
21659 return NULL;
21660 }
21661
21662
21663 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj;
21665 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21666 bool arg2 = (bool) true ;
21667 PyObject * obj0 = 0 ;
21668 PyObject * obj1 = 0 ;
21669 char *kwnames[] = {
21670 (char *) "self",(char *) "needMore", NULL
21671 };
21672
21673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21675 if (SWIG_arg_fail(1)) SWIG_fail;
21676 if (obj1) {
21677 {
21678 arg2 = (bool)(SWIG_As_bool(obj1));
21679 if (SWIG_arg_fail(2)) SWIG_fail;
21680 }
21681 }
21682 {
21683 PyThreadState* __tstate = wxPyBeginAllowThreads();
21684 (arg1)->RequestMore(arg2);
21685
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 Py_INCREF(Py_None); resultobj = Py_None;
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21697 PyObject *resultobj;
21698 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21699 bool result;
21700 PyObject * obj0 = 0 ;
21701 char *kwnames[] = {
21702 (char *) "self", NULL
21703 };
21704
21705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21707 if (SWIG_arg_fail(1)) SWIG_fail;
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21711
21712 wxPyEndAllowThreads(__tstate);
21713 if (PyErr_Occurred()) SWIG_fail;
21714 }
21715 {
21716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21717 }
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21725 PyObject *resultobj;
21726 wxIdleMode arg1 ;
21727 PyObject * obj0 = 0 ;
21728 char *kwnames[] = {
21729 (char *) "mode", NULL
21730 };
21731
21732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21733 {
21734 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21735 if (SWIG_arg_fail(1)) SWIG_fail;
21736 }
21737 {
21738 PyThreadState* __tstate = wxPyBeginAllowThreads();
21739 wxIdleEvent::SetMode((wxIdleMode )arg1);
21740
21741 wxPyEndAllowThreads(__tstate);
21742 if (PyErr_Occurred()) SWIG_fail;
21743 }
21744 Py_INCREF(Py_None); resultobj = Py_None;
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj;
21753 wxIdleMode result;
21754 char *kwnames[] = {
21755 NULL
21756 };
21757
21758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = (wxIdleMode)wxIdleEvent::GetMode();
21762
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 resultobj = SWIG_From_int((result));
21767 return resultobj;
21768 fail:
21769 return NULL;
21770 }
21771
21772
21773 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21774 PyObject *resultobj;
21775 wxWindow *arg1 = (wxWindow *) 0 ;
21776 bool result;
21777 PyObject * obj0 = 0 ;
21778 char *kwnames[] = {
21779 (char *) "win", NULL
21780 };
21781
21782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21784 if (SWIG_arg_fail(1)) SWIG_fail;
21785 {
21786 PyThreadState* __tstate = wxPyBeginAllowThreads();
21787 result = (bool)wxIdleEvent::CanSend(arg1);
21788
21789 wxPyEndAllowThreads(__tstate);
21790 if (PyErr_Occurred()) SWIG_fail;
21791 }
21792 {
21793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21794 }
21795 return resultobj;
21796 fail:
21797 return NULL;
21798 }
21799
21800
21801 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21802 PyObject *obj;
21803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21804 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21805 Py_INCREF(obj);
21806 return Py_BuildValue((char *)"");
21807 }
21808 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21809 PyObject *resultobj;
21810 int arg1 = (int) 0 ;
21811 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21812 wxPyEvent *result;
21813 PyObject * obj0 = 0 ;
21814 PyObject * obj1 = 0 ;
21815 char *kwnames[] = {
21816 (char *) "winid",(char *) "commandType", NULL
21817 };
21818
21819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21820 if (obj0) {
21821 {
21822 arg1 = (int)(SWIG_As_int(obj0));
21823 if (SWIG_arg_fail(1)) SWIG_fail;
21824 }
21825 }
21826 if (obj1) {
21827 {
21828 arg2 = (wxEventType)(SWIG_As_int(obj1));
21829 if (SWIG_arg_fail(2)) SWIG_fail;
21830 }
21831 }
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21835
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21847 PyObject *resultobj;
21848 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21849 PyObject * obj0 = 0 ;
21850 char *kwnames[] = {
21851 (char *) "self", NULL
21852 };
21853
21854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21856 if (SWIG_arg_fail(1)) SWIG_fail;
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 delete arg1;
21860
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 Py_INCREF(Py_None); resultobj = Py_None;
21865 return resultobj;
21866 fail:
21867 return NULL;
21868 }
21869
21870
21871 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21872 PyObject *resultobj;
21873 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21874 PyObject *arg2 = (PyObject *) 0 ;
21875 PyObject * obj0 = 0 ;
21876 PyObject * obj1 = 0 ;
21877 char *kwnames[] = {
21878 (char *) "self",(char *) "self", NULL
21879 };
21880
21881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21883 if (SWIG_arg_fail(1)) SWIG_fail;
21884 arg2 = obj1;
21885 {
21886 PyThreadState* __tstate = wxPyBeginAllowThreads();
21887 (arg1)->SetSelf(arg2);
21888
21889 wxPyEndAllowThreads(__tstate);
21890 if (PyErr_Occurred()) SWIG_fail;
21891 }
21892 Py_INCREF(Py_None); resultobj = Py_None;
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21900 PyObject *resultobj;
21901 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21902 PyObject *result;
21903 PyObject * obj0 = 0 ;
21904 char *kwnames[] = {
21905 (char *) "self", NULL
21906 };
21907
21908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21910 if (SWIG_arg_fail(1)) SWIG_fail;
21911 {
21912 PyThreadState* __tstate = wxPyBeginAllowThreads();
21913 result = (PyObject *)(arg1)->GetSelf();
21914
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 resultobj = result;
21919 return resultobj;
21920 fail:
21921 return NULL;
21922 }
21923
21924
21925 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21926 PyObject *obj;
21927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21928 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21929 Py_INCREF(obj);
21930 return Py_BuildValue((char *)"");
21931 }
21932 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21933 PyObject *resultobj;
21934 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21935 int arg2 = (int) 0 ;
21936 wxPyCommandEvent *result;
21937 PyObject * obj0 = 0 ;
21938 PyObject * obj1 = 0 ;
21939 char *kwnames[] = {
21940 (char *) "commandType",(char *) "id", NULL
21941 };
21942
21943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21944 if (obj0) {
21945 {
21946 arg1 = (wxEventType)(SWIG_As_int(obj0));
21947 if (SWIG_arg_fail(1)) SWIG_fail;
21948 }
21949 }
21950 if (obj1) {
21951 {
21952 arg2 = (int)(SWIG_As_int(obj1));
21953 if (SWIG_arg_fail(2)) SWIG_fail;
21954 }
21955 }
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21959
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21964 return resultobj;
21965 fail:
21966 return NULL;
21967 }
21968
21969
21970 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21971 PyObject *resultobj;
21972 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21973 PyObject * obj0 = 0 ;
21974 char *kwnames[] = {
21975 (char *) "self", NULL
21976 };
21977
21978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21980 if (SWIG_arg_fail(1)) SWIG_fail;
21981 {
21982 PyThreadState* __tstate = wxPyBeginAllowThreads();
21983 delete arg1;
21984
21985 wxPyEndAllowThreads(__tstate);
21986 if (PyErr_Occurred()) SWIG_fail;
21987 }
21988 Py_INCREF(Py_None); resultobj = Py_None;
21989 return resultobj;
21990 fail:
21991 return NULL;
21992 }
21993
21994
21995 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21996 PyObject *resultobj;
21997 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21998 PyObject *arg2 = (PyObject *) 0 ;
21999 PyObject * obj0 = 0 ;
22000 PyObject * obj1 = 0 ;
22001 char *kwnames[] = {
22002 (char *) "self",(char *) "self", NULL
22003 };
22004
22005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22007 if (SWIG_arg_fail(1)) SWIG_fail;
22008 arg2 = obj1;
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 (arg1)->SetSelf(arg2);
22012
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 Py_INCREF(Py_None); resultobj = Py_None;
22017 return resultobj;
22018 fail:
22019 return NULL;
22020 }
22021
22022
22023 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22024 PyObject *resultobj;
22025 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22026 PyObject *result;
22027 PyObject * obj0 = 0 ;
22028 char *kwnames[] = {
22029 (char *) "self", NULL
22030 };
22031
22032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22034 if (SWIG_arg_fail(1)) SWIG_fail;
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (PyObject *)(arg1)->GetSelf();
22038
22039 wxPyEndAllowThreads(__tstate);
22040 if (PyErr_Occurred()) SWIG_fail;
22041 }
22042 resultobj = result;
22043 return resultobj;
22044 fail:
22045 return NULL;
22046 }
22047
22048
22049 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22050 PyObject *obj;
22051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22052 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22053 Py_INCREF(obj);
22054 return Py_BuildValue((char *)"");
22055 }
22056 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22057 PyObject *resultobj;
22058 wxWindow *arg1 = (wxWindow *) 0 ;
22059 wxDateTime *arg2 = 0 ;
22060 wxEventType arg3 ;
22061 wxDateEvent *result;
22062 PyObject * obj0 = 0 ;
22063 PyObject * obj1 = 0 ;
22064 PyObject * obj2 = 0 ;
22065 char *kwnames[] = {
22066 (char *) "win",(char *) "dt",(char *) "type", NULL
22067 };
22068
22069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22071 if (SWIG_arg_fail(1)) SWIG_fail;
22072 {
22073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22074 if (SWIG_arg_fail(2)) SWIG_fail;
22075 if (arg2 == NULL) {
22076 SWIG_null_ref("wxDateTime");
22077 }
22078 if (SWIG_arg_fail(2)) SWIG_fail;
22079 }
22080 {
22081 arg3 = (wxEventType)(SWIG_As_int(obj2));
22082 if (SWIG_arg_fail(3)) SWIG_fail;
22083 }
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22087
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22092 return resultobj;
22093 fail:
22094 return NULL;
22095 }
22096
22097
22098 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22099 PyObject *resultobj;
22100 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22101 wxDateTime *result;
22102 PyObject * obj0 = 0 ;
22103 char *kwnames[] = {
22104 (char *) "self", NULL
22105 };
22106
22107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(1)) SWIG_fail;
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 {
22113 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22114 result = (wxDateTime *) &_result_ref;
22115 }
22116
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22121 return resultobj;
22122 fail:
22123 return NULL;
22124 }
22125
22126
22127 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22128 PyObject *resultobj;
22129 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22130 wxDateTime *arg2 = 0 ;
22131 PyObject * obj0 = 0 ;
22132 PyObject * obj1 = 0 ;
22133 char *kwnames[] = {
22134 (char *) "self",(char *) "date", NULL
22135 };
22136
22137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22139 if (SWIG_arg_fail(1)) SWIG_fail;
22140 {
22141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22142 if (SWIG_arg_fail(2)) SWIG_fail;
22143 if (arg2 == NULL) {
22144 SWIG_null_ref("wxDateTime");
22145 }
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 }
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 (arg1)->SetDate((wxDateTime const &)*arg2);
22151
22152 wxPyEndAllowThreads(__tstate);
22153 if (PyErr_Occurred()) SWIG_fail;
22154 }
22155 Py_INCREF(Py_None); resultobj = Py_None;
22156 return resultobj;
22157 fail:
22158 return NULL;
22159 }
22160
22161
22162 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22163 PyObject *obj;
22164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22165 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22166 Py_INCREF(obj);
22167 return Py_BuildValue((char *)"");
22168 }
22169 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22170 PyObject *resultobj;
22171 wxPyApp *result;
22172 char *kwnames[] = {
22173 NULL
22174 };
22175
22176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (wxPyApp *)new_wxPyApp();
22180
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22192 PyObject *resultobj;
22193 wxPyApp *arg1 = (wxPyApp *) 0 ;
22194 PyObject * obj0 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(1)) SWIG_fail;
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 delete arg1;
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 Py_INCREF(Py_None); resultobj = Py_None;
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj;
22218 wxPyApp *arg1 = (wxPyApp *) 0 ;
22219 PyObject *arg2 = (PyObject *) 0 ;
22220 PyObject *arg3 = (PyObject *) 0 ;
22221 PyObject * obj0 = 0 ;
22222 PyObject * obj1 = 0 ;
22223 PyObject * obj2 = 0 ;
22224 char *kwnames[] = {
22225 (char *) "self",(char *) "self",(char *) "_class", NULL
22226 };
22227
22228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(1)) SWIG_fail;
22231 arg2 = obj1;
22232 arg3 = obj2;
22233 {
22234 PyThreadState* __tstate = wxPyBeginAllowThreads();
22235 (arg1)->_setCallbackInfo(arg2,arg3);
22236
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 Py_INCREF(Py_None); resultobj = Py_None;
22241 return resultobj;
22242 fail:
22243 return NULL;
22244 }
22245
22246
22247 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22248 PyObject *resultobj;
22249 wxPyApp *arg1 = (wxPyApp *) 0 ;
22250 wxString result;
22251 PyObject * obj0 = 0 ;
22252 char *kwnames[] = {
22253 (char *) "self", NULL
22254 };
22255
22256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22258 if (SWIG_arg_fail(1)) SWIG_fail;
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 result = ((wxPyApp const *)arg1)->GetAppName();
22262
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 {
22267 #if wxUSE_UNICODE
22268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22269 #else
22270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22271 #endif
22272 }
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 wxPyApp *arg1 = (wxPyApp *) 0 ;
22282 wxString *arg2 = 0 ;
22283 bool temp2 = false ;
22284 PyObject * obj0 = 0 ;
22285 PyObject * obj1 = 0 ;
22286 char *kwnames[] = {
22287 (char *) "self",(char *) "name", NULL
22288 };
22289
22290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22292 if (SWIG_arg_fail(1)) SWIG_fail;
22293 {
22294 arg2 = wxString_in_helper(obj1);
22295 if (arg2 == NULL) SWIG_fail;
22296 temp2 = true;
22297 }
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 (arg1)->SetAppName((wxString const &)*arg2);
22301
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 Py_INCREF(Py_None); resultobj = Py_None;
22306 {
22307 if (temp2)
22308 delete arg2;
22309 }
22310 return resultobj;
22311 fail:
22312 {
22313 if (temp2)
22314 delete arg2;
22315 }
22316 return NULL;
22317 }
22318
22319
22320 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22321 PyObject *resultobj;
22322 wxPyApp *arg1 = (wxPyApp *) 0 ;
22323 wxString result;
22324 PyObject * obj0 = 0 ;
22325 char *kwnames[] = {
22326 (char *) "self", NULL
22327 };
22328
22329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22331 if (SWIG_arg_fail(1)) SWIG_fail;
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 result = ((wxPyApp const *)arg1)->GetClassName();
22335
22336 wxPyEndAllowThreads(__tstate);
22337 if (PyErr_Occurred()) SWIG_fail;
22338 }
22339 {
22340 #if wxUSE_UNICODE
22341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22342 #else
22343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22344 #endif
22345 }
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxPyApp *arg1 = (wxPyApp *) 0 ;
22355 wxString *arg2 = 0 ;
22356 bool temp2 = false ;
22357 PyObject * obj0 = 0 ;
22358 PyObject * obj1 = 0 ;
22359 char *kwnames[] = {
22360 (char *) "self",(char *) "name", NULL
22361 };
22362
22363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22365 if (SWIG_arg_fail(1)) SWIG_fail;
22366 {
22367 arg2 = wxString_in_helper(obj1);
22368 if (arg2 == NULL) SWIG_fail;
22369 temp2 = true;
22370 }
22371 {
22372 PyThreadState* __tstate = wxPyBeginAllowThreads();
22373 (arg1)->SetClassName((wxString const &)*arg2);
22374
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 Py_INCREF(Py_None); resultobj = Py_None;
22379 {
22380 if (temp2)
22381 delete arg2;
22382 }
22383 return resultobj;
22384 fail:
22385 {
22386 if (temp2)
22387 delete arg2;
22388 }
22389 return NULL;
22390 }
22391
22392
22393 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22394 PyObject *resultobj;
22395 wxPyApp *arg1 = (wxPyApp *) 0 ;
22396 wxString *result;
22397 PyObject * obj0 = 0 ;
22398 char *kwnames[] = {
22399 (char *) "self", NULL
22400 };
22401
22402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22404 if (SWIG_arg_fail(1)) SWIG_fail;
22405 {
22406 PyThreadState* __tstate = wxPyBeginAllowThreads();
22407 {
22408 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22409 result = (wxString *) &_result_ref;
22410 }
22411
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 {
22416 #if wxUSE_UNICODE
22417 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22418 #else
22419 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22420 #endif
22421 }
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxPyApp *arg1 = (wxPyApp *) 0 ;
22431 wxString *arg2 = 0 ;
22432 bool temp2 = false ;
22433 PyObject * obj0 = 0 ;
22434 PyObject * obj1 = 0 ;
22435 char *kwnames[] = {
22436 (char *) "self",(char *) "name", NULL
22437 };
22438
22439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22441 if (SWIG_arg_fail(1)) SWIG_fail;
22442 {
22443 arg2 = wxString_in_helper(obj1);
22444 if (arg2 == NULL) SWIG_fail;
22445 temp2 = true;
22446 }
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 (arg1)->SetVendorName((wxString const &)*arg2);
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 Py_INCREF(Py_None); resultobj = Py_None;
22455 {
22456 if (temp2)
22457 delete arg2;
22458 }
22459 return resultobj;
22460 fail:
22461 {
22462 if (temp2)
22463 delete arg2;
22464 }
22465 return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22470 PyObject *resultobj;
22471 wxPyApp *arg1 = (wxPyApp *) 0 ;
22472 wxAppTraits *result;
22473 PyObject * obj0 = 0 ;
22474 char *kwnames[] = {
22475 (char *) "self", NULL
22476 };
22477
22478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 {
22482 PyThreadState* __tstate = wxPyBeginAllowThreads();
22483 result = (wxAppTraits *)(arg1)->GetTraits();
22484
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22489 return resultobj;
22490 fail:
22491 return NULL;
22492 }
22493
22494
22495 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22496 PyObject *resultobj;
22497 wxPyApp *arg1 = (wxPyApp *) 0 ;
22498 PyObject * obj0 = 0 ;
22499 char *kwnames[] = {
22500 (char *) "self", NULL
22501 };
22502
22503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22505 if (SWIG_arg_fail(1)) SWIG_fail;
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 (arg1)->ProcessPendingEvents();
22509
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 Py_INCREF(Py_None); resultobj = Py_None;
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22521 PyObject *resultobj;
22522 wxPyApp *arg1 = (wxPyApp *) 0 ;
22523 bool arg2 = (bool) false ;
22524 bool result;
22525 PyObject * obj0 = 0 ;
22526 PyObject * obj1 = 0 ;
22527 char *kwnames[] = {
22528 (char *) "self",(char *) "onlyIfNeeded", NULL
22529 };
22530
22531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22533 if (SWIG_arg_fail(1)) SWIG_fail;
22534 if (obj1) {
22535 {
22536 arg2 = (bool)(SWIG_As_bool(obj1));
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 }
22539 }
22540 {
22541 PyThreadState* __tstate = wxPyBeginAllowThreads();
22542 result = (bool)(arg1)->Yield(arg2);
22543
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 {
22548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22549 }
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj;
22558 wxPyApp *arg1 = (wxPyApp *) 0 ;
22559 PyObject * obj0 = 0 ;
22560 char *kwnames[] = {
22561 (char *) "self", NULL
22562 };
22563
22564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22566 if (SWIG_arg_fail(1)) SWIG_fail;
22567 {
22568 PyThreadState* __tstate = wxPyBeginAllowThreads();
22569 (arg1)->WakeUpIdle();
22570
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 Py_INCREF(Py_None); resultobj = Py_None;
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22582 PyObject *resultobj;
22583 bool result;
22584 char *kwnames[] = {
22585 NULL
22586 };
22587
22588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 result = (bool)wxPyApp::IsMainLoopRunning();
22592
22593 wxPyEndAllowThreads(__tstate);
22594 if (PyErr_Occurred()) SWIG_fail;
22595 }
22596 {
22597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22598 }
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22606 PyObject *resultobj;
22607 wxPyApp *arg1 = (wxPyApp *) 0 ;
22608 int result;
22609 PyObject * obj0 = 0 ;
22610 char *kwnames[] = {
22611 (char *) "self", NULL
22612 };
22613
22614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22616 if (SWIG_arg_fail(1)) SWIG_fail;
22617 {
22618 PyThreadState* __tstate = wxPyBeginAllowThreads();
22619 result = (int)(arg1)->MainLoop();
22620
22621 wxPyEndAllowThreads(__tstate);
22622 if (PyErr_Occurred()) SWIG_fail;
22623 }
22624 {
22625 resultobj = SWIG_From_int((int)(result));
22626 }
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj;
22635 wxPyApp *arg1 = (wxPyApp *) 0 ;
22636 PyObject * obj0 = 0 ;
22637 char *kwnames[] = {
22638 (char *) "self", NULL
22639 };
22640
22641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22643 if (SWIG_arg_fail(1)) SWIG_fail;
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 (arg1)->Exit();
22647
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 Py_INCREF(Py_None); resultobj = Py_None;
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22659 PyObject *resultobj;
22660 wxPyApp *arg1 = (wxPyApp *) 0 ;
22661 PyObject * obj0 = 0 ;
22662 char *kwnames[] = {
22663 (char *) "self", NULL
22664 };
22665
22666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22668 if (SWIG_arg_fail(1)) SWIG_fail;
22669 {
22670 PyThreadState* __tstate = wxPyBeginAllowThreads();
22671 (arg1)->ExitMainLoop();
22672
22673 wxPyEndAllowThreads(__tstate);
22674 if (PyErr_Occurred()) SWIG_fail;
22675 }
22676 Py_INCREF(Py_None); resultobj = Py_None;
22677 return resultobj;
22678 fail:
22679 return NULL;
22680 }
22681
22682
22683 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22684 PyObject *resultobj;
22685 wxPyApp *arg1 = (wxPyApp *) 0 ;
22686 bool result;
22687 PyObject * obj0 = 0 ;
22688 char *kwnames[] = {
22689 (char *) "self", NULL
22690 };
22691
22692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22694 if (SWIG_arg_fail(1)) SWIG_fail;
22695 {
22696 PyThreadState* __tstate = wxPyBeginAllowThreads();
22697 result = (bool)(arg1)->Pending();
22698
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 {
22703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22704 }
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22712 PyObject *resultobj;
22713 wxPyApp *arg1 = (wxPyApp *) 0 ;
22714 bool result;
22715 PyObject * obj0 = 0 ;
22716 char *kwnames[] = {
22717 (char *) "self", NULL
22718 };
22719
22720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22722 if (SWIG_arg_fail(1)) SWIG_fail;
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 result = (bool)(arg1)->Dispatch();
22726
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 {
22731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22732 }
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22740 PyObject *resultobj;
22741 wxPyApp *arg1 = (wxPyApp *) 0 ;
22742 bool result;
22743 PyObject * obj0 = 0 ;
22744 char *kwnames[] = {
22745 (char *) "self", NULL
22746 };
22747
22748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(1)) SWIG_fail;
22751 {
22752 PyThreadState* __tstate = wxPyBeginAllowThreads();
22753 result = (bool)(arg1)->ProcessIdle();
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 {
22759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22760 }
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22768 PyObject *resultobj;
22769 wxPyApp *arg1 = (wxPyApp *) 0 ;
22770 wxWindow *arg2 = (wxWindow *) 0 ;
22771 wxIdleEvent *arg3 = 0 ;
22772 bool result;
22773 PyObject * obj0 = 0 ;
22774 PyObject * obj1 = 0 ;
22775 PyObject * obj2 = 0 ;
22776 char *kwnames[] = {
22777 (char *) "self",(char *) "win",(char *) "event", NULL
22778 };
22779
22780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22782 if (SWIG_arg_fail(1)) SWIG_fail;
22783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22784 if (SWIG_arg_fail(2)) SWIG_fail;
22785 {
22786 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22787 if (SWIG_arg_fail(3)) SWIG_fail;
22788 if (arg3 == NULL) {
22789 SWIG_null_ref("wxIdleEvent");
22790 }
22791 if (SWIG_arg_fail(3)) SWIG_fail;
22792 }
22793 {
22794 PyThreadState* __tstate = wxPyBeginAllowThreads();
22795 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22796
22797 wxPyEndAllowThreads(__tstate);
22798 if (PyErr_Occurred()) SWIG_fail;
22799 }
22800 {
22801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22802 }
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22810 PyObject *resultobj;
22811 wxPyApp *arg1 = (wxPyApp *) 0 ;
22812 bool result;
22813 PyObject * obj0 = 0 ;
22814 char *kwnames[] = {
22815 (char *) "self", NULL
22816 };
22817
22818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22820 if (SWIG_arg_fail(1)) SWIG_fail;
22821 {
22822 PyThreadState* __tstate = wxPyBeginAllowThreads();
22823 result = (bool)((wxPyApp const *)arg1)->IsActive();
22824
22825 wxPyEndAllowThreads(__tstate);
22826 if (PyErr_Occurred()) SWIG_fail;
22827 }
22828 {
22829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22830 }
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22838 PyObject *resultobj;
22839 wxPyApp *arg1 = (wxPyApp *) 0 ;
22840 wxWindow *arg2 = (wxWindow *) 0 ;
22841 PyObject * obj0 = 0 ;
22842 PyObject * obj1 = 0 ;
22843 char *kwnames[] = {
22844 (char *) "self",(char *) "win", NULL
22845 };
22846
22847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22849 if (SWIG_arg_fail(1)) SWIG_fail;
22850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22851 if (SWIG_arg_fail(2)) SWIG_fail;
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 (arg1)->SetTopWindow(arg2);
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 Py_INCREF(Py_None); resultobj = Py_None;
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj;
22868 wxPyApp *arg1 = (wxPyApp *) 0 ;
22869 wxWindow *result;
22870 PyObject * obj0 = 0 ;
22871 char *kwnames[] = {
22872 (char *) "self", NULL
22873 };
22874
22875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22877 if (SWIG_arg_fail(1)) SWIG_fail;
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22881
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 {
22886 resultobj = wxPyMake_wxObject(result, 0);
22887 }
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj;
22896 wxPyApp *arg1 = (wxPyApp *) 0 ;
22897 bool arg2 ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 char *kwnames[] = {
22901 (char *) "self",(char *) "flag", NULL
22902 };
22903
22904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",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 = (bool)(SWIG_As_bool(obj1));
22909 if (SWIG_arg_fail(2)) SWIG_fail;
22910 }
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 (arg1)->SetExitOnFrameDelete(arg2);
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 Py_INCREF(Py_None); resultobj = Py_None;
22919 return resultobj;
22920 fail:
22921 return NULL;
22922 }
22923
22924
22925 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22926 PyObject *resultobj;
22927 wxPyApp *arg1 = (wxPyApp *) 0 ;
22928 bool result;
22929 PyObject * obj0 = 0 ;
22930 char *kwnames[] = {
22931 (char *) "self", NULL
22932 };
22933
22934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22936 if (SWIG_arg_fail(1)) SWIG_fail;
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22940
22941 wxPyEndAllowThreads(__tstate);
22942 if (PyErr_Occurred()) SWIG_fail;
22943 }
22944 {
22945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22946 }
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22954 PyObject *resultobj;
22955 wxPyApp *arg1 = (wxPyApp *) 0 ;
22956 bool arg2 ;
22957 PyObject * obj0 = 0 ;
22958 PyObject * obj1 = 0 ;
22959 char *kwnames[] = {
22960 (char *) "self",(char *) "flag", NULL
22961 };
22962
22963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22965 if (SWIG_arg_fail(1)) SWIG_fail;
22966 {
22967 arg2 = (bool)(SWIG_As_bool(obj1));
22968 if (SWIG_arg_fail(2)) SWIG_fail;
22969 }
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 (arg1)->SetUseBestVisual(arg2);
22973
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 Py_INCREF(Py_None); resultobj = Py_None;
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj;
22986 wxPyApp *arg1 = (wxPyApp *) 0 ;
22987 bool result;
22988 PyObject * obj0 = 0 ;
22989 char *kwnames[] = {
22990 (char *) "self", NULL
22991 };
22992
22993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22995 if (SWIG_arg_fail(1)) SWIG_fail;
22996 {
22997 PyThreadState* __tstate = wxPyBeginAllowThreads();
22998 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22999
23000 wxPyEndAllowThreads(__tstate);
23001 if (PyErr_Occurred()) SWIG_fail;
23002 }
23003 {
23004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23005 }
23006 return resultobj;
23007 fail:
23008 return NULL;
23009 }
23010
23011
23012 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23013 PyObject *resultobj;
23014 wxPyApp *arg1 = (wxPyApp *) 0 ;
23015 int arg2 ;
23016 PyObject * obj0 = 0 ;
23017 PyObject * obj1 = 0 ;
23018 char *kwnames[] = {
23019 (char *) "self",(char *) "mode", NULL
23020 };
23021
23022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(1)) SWIG_fail;
23025 {
23026 arg2 = (int)(SWIG_As_int(obj1));
23027 if (SWIG_arg_fail(2)) SWIG_fail;
23028 }
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 (arg1)->SetPrintMode(arg2);
23032
23033 wxPyEndAllowThreads(__tstate);
23034 if (PyErr_Occurred()) SWIG_fail;
23035 }
23036 Py_INCREF(Py_None); resultobj = Py_None;
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23044 PyObject *resultobj;
23045 wxPyApp *arg1 = (wxPyApp *) 0 ;
23046 int result;
23047 PyObject * obj0 = 0 ;
23048 char *kwnames[] = {
23049 (char *) "self", NULL
23050 };
23051
23052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(1)) SWIG_fail;
23055 {
23056 PyThreadState* __tstate = wxPyBeginAllowThreads();
23057 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23058
23059 wxPyEndAllowThreads(__tstate);
23060 if (PyErr_Occurred()) SWIG_fail;
23061 }
23062 {
23063 resultobj = SWIG_From_int((int)(result));
23064 }
23065 return resultobj;
23066 fail:
23067 return NULL;
23068 }
23069
23070
23071 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23072 PyObject *resultobj;
23073 wxPyApp *arg1 = (wxPyApp *) 0 ;
23074 int arg2 ;
23075 PyObject * obj0 = 0 ;
23076 PyObject * obj1 = 0 ;
23077 char *kwnames[] = {
23078 (char *) "self",(char *) "mode", NULL
23079 };
23080
23081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23083 if (SWIG_arg_fail(1)) SWIG_fail;
23084 {
23085 arg2 = (int)(SWIG_As_int(obj1));
23086 if (SWIG_arg_fail(2)) SWIG_fail;
23087 }
23088 {
23089 PyThreadState* __tstate = wxPyBeginAllowThreads();
23090 (arg1)->SetAssertMode(arg2);
23091
23092 wxPyEndAllowThreads(__tstate);
23093 if (PyErr_Occurred()) SWIG_fail;
23094 }
23095 Py_INCREF(Py_None); resultobj = Py_None;
23096 return resultobj;
23097 fail:
23098 return NULL;
23099 }
23100
23101
23102 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23103 PyObject *resultobj;
23104 wxPyApp *arg1 = (wxPyApp *) 0 ;
23105 int result;
23106 PyObject * obj0 = 0 ;
23107 char *kwnames[] = {
23108 (char *) "self", NULL
23109 };
23110
23111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23113 if (SWIG_arg_fail(1)) SWIG_fail;
23114 {
23115 PyThreadState* __tstate = wxPyBeginAllowThreads();
23116 result = (int)(arg1)->GetAssertMode();
23117
23118 wxPyEndAllowThreads(__tstate);
23119 if (PyErr_Occurred()) SWIG_fail;
23120 }
23121 {
23122 resultobj = SWIG_From_int((int)(result));
23123 }
23124 return resultobj;
23125 fail:
23126 return NULL;
23127 }
23128
23129
23130 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23131 PyObject *resultobj;
23132 bool result;
23133 char *kwnames[] = {
23134 NULL
23135 };
23136
23137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23138 {
23139 PyThreadState* __tstate = wxPyBeginAllowThreads();
23140 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23141
23142 wxPyEndAllowThreads(__tstate);
23143 if (PyErr_Occurred()) SWIG_fail;
23144 }
23145 {
23146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23147 }
23148 return resultobj;
23149 fail:
23150 return NULL;
23151 }
23152
23153
23154 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23155 PyObject *resultobj;
23156 long result;
23157 char *kwnames[] = {
23158 NULL
23159 };
23160
23161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23162 {
23163 PyThreadState* __tstate = wxPyBeginAllowThreads();
23164 result = (long)wxPyApp::GetMacAboutMenuItemId();
23165
23166 wxPyEndAllowThreads(__tstate);
23167 if (PyErr_Occurred()) SWIG_fail;
23168 }
23169 {
23170 resultobj = SWIG_From_long((long)(result));
23171 }
23172 return resultobj;
23173 fail:
23174 return NULL;
23175 }
23176
23177
23178 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj;
23180 long result;
23181 char *kwnames[] = {
23182 NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23189
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 {
23194 resultobj = SWIG_From_long((long)(result));
23195 }
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj;
23204 long result;
23205 char *kwnames[] = {
23206 NULL
23207 };
23208
23209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 result = (long)wxPyApp::GetMacExitMenuItemId();
23213
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 {
23218 resultobj = SWIG_From_long((long)(result));
23219 }
23220 return resultobj;
23221 fail:
23222 return NULL;
23223 }
23224
23225
23226 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23227 PyObject *resultobj;
23228 wxString result;
23229 char *kwnames[] = {
23230 NULL
23231 };
23232
23233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23234 {
23235 PyThreadState* __tstate = wxPyBeginAllowThreads();
23236 result = wxPyApp::GetMacHelpMenuTitleName();
23237
23238 wxPyEndAllowThreads(__tstate);
23239 if (PyErr_Occurred()) SWIG_fail;
23240 }
23241 {
23242 #if wxUSE_UNICODE
23243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23244 #else
23245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23246 #endif
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj;
23256 bool arg1 ;
23257 PyObject * obj0 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "val", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23263 {
23264 arg1 = (bool)(SWIG_As_bool(obj0));
23265 if (SWIG_arg_fail(1)) SWIG_fail;
23266 }
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23270
23271 wxPyEndAllowThreads(__tstate);
23272 if (PyErr_Occurred()) SWIG_fail;
23273 }
23274 Py_INCREF(Py_None); resultobj = Py_None;
23275 return resultobj;
23276 fail:
23277 return NULL;
23278 }
23279
23280
23281 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23282 PyObject *resultobj;
23283 long arg1 ;
23284 PyObject * obj0 = 0 ;
23285 char *kwnames[] = {
23286 (char *) "val", NULL
23287 };
23288
23289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23290 {
23291 arg1 = (long)(SWIG_As_long(obj0));
23292 if (SWIG_arg_fail(1)) SWIG_fail;
23293 }
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 wxPyApp::SetMacAboutMenuItemId(arg1);
23297
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 Py_INCREF(Py_None); resultobj = Py_None;
23302 return resultobj;
23303 fail:
23304 return NULL;
23305 }
23306
23307
23308 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23309 PyObject *resultobj;
23310 long arg1 ;
23311 PyObject * obj0 = 0 ;
23312 char *kwnames[] = {
23313 (char *) "val", NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23317 {
23318 arg1 = (long)(SWIG_As_long(obj0));
23319 if (SWIG_arg_fail(1)) SWIG_fail;
23320 }
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23324
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 Py_INCREF(Py_None); resultobj = Py_None;
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj;
23337 long arg1 ;
23338 PyObject * obj0 = 0 ;
23339 char *kwnames[] = {
23340 (char *) "val", NULL
23341 };
23342
23343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23344 {
23345 arg1 = (long)(SWIG_As_long(obj0));
23346 if (SWIG_arg_fail(1)) SWIG_fail;
23347 }
23348 {
23349 PyThreadState* __tstate = wxPyBeginAllowThreads();
23350 wxPyApp::SetMacExitMenuItemId(arg1);
23351
23352 wxPyEndAllowThreads(__tstate);
23353 if (PyErr_Occurred()) SWIG_fail;
23354 }
23355 Py_INCREF(Py_None); resultobj = Py_None;
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23363 PyObject *resultobj;
23364 wxString *arg1 = 0 ;
23365 bool temp1 = false ;
23366 PyObject * obj0 = 0 ;
23367 char *kwnames[] = {
23368 (char *) "val", NULL
23369 };
23370
23371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23372 {
23373 arg1 = wxString_in_helper(obj0);
23374 if (arg1 == NULL) SWIG_fail;
23375 temp1 = true;
23376 }
23377 {
23378 PyThreadState* __tstate = wxPyBeginAllowThreads();
23379 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23380
23381 wxPyEndAllowThreads(__tstate);
23382 if (PyErr_Occurred()) SWIG_fail;
23383 }
23384 Py_INCREF(Py_None); resultobj = Py_None;
23385 {
23386 if (temp1)
23387 delete arg1;
23388 }
23389 return resultobj;
23390 fail:
23391 {
23392 if (temp1)
23393 delete arg1;
23394 }
23395 return NULL;
23396 }
23397
23398
23399 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23400 PyObject *resultobj;
23401 wxPyApp *arg1 = (wxPyApp *) 0 ;
23402 PyObject * obj0 = 0 ;
23403 char *kwnames[] = {
23404 (char *) "self", NULL
23405 };
23406
23407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23409 if (SWIG_arg_fail(1)) SWIG_fail;
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 (arg1)->_BootstrapApp();
23413
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 Py_INCREF(Py_None); resultobj = Py_None;
23418 return resultobj;
23419 fail:
23420 return NULL;
23421 }
23422
23423
23424 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23425 PyObject *resultobj;
23426 int result;
23427 char *kwnames[] = {
23428 NULL
23429 };
23430
23431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23432 {
23433 PyThreadState* __tstate = wxPyBeginAllowThreads();
23434 result = (int)PyApp_GetComCtl32Version();
23435
23436 wxPyEndAllowThreads(__tstate);
23437 if (PyErr_Occurred()) SWIG_fail;
23438 }
23439 {
23440 resultobj = SWIG_From_int((int)(result));
23441 }
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23449 PyObject *obj;
23450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23451 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23452 Py_INCREF(obj);
23453 return Py_BuildValue((char *)"");
23454 }
23455 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23456 PyObject *resultobj;
23457 char *kwnames[] = {
23458 NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23462 {
23463 PyThreadState* __tstate = wxPyBeginAllowThreads();
23464 wxExit();
23465
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 Py_INCREF(Py_None); resultobj = Py_None;
23470 return resultobj;
23471 fail:
23472 return NULL;
23473 }
23474
23475
23476 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj;
23478 bool result;
23479 char *kwnames[] = {
23480 NULL
23481 };
23482
23483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23484 {
23485 PyThreadState* __tstate = wxPyBeginAllowThreads();
23486 result = (bool)wxYield();
23487
23488 wxPyEndAllowThreads(__tstate);
23489 if (PyErr_Occurred()) SWIG_fail;
23490 }
23491 {
23492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23493 }
23494 return resultobj;
23495 fail:
23496 return NULL;
23497 }
23498
23499
23500 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23501 PyObject *resultobj;
23502 bool result;
23503 char *kwnames[] = {
23504 NULL
23505 };
23506
23507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 result = (bool)wxYieldIfNeeded();
23511
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23517 }
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23525 PyObject *resultobj;
23526 wxWindow *arg1 = (wxWindow *) NULL ;
23527 bool arg2 = (bool) false ;
23528 bool result;
23529 PyObject * obj0 = 0 ;
23530 PyObject * obj1 = 0 ;
23531 char *kwnames[] = {
23532 (char *) "win",(char *) "onlyIfNeeded", NULL
23533 };
23534
23535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23536 if (obj0) {
23537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23538 if (SWIG_arg_fail(1)) SWIG_fail;
23539 }
23540 if (obj1) {
23541 {
23542 arg2 = (bool)(SWIG_As_bool(obj1));
23543 if (SWIG_arg_fail(2)) SWIG_fail;
23544 }
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (bool)wxSafeYield(arg1,arg2);
23549
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 {
23554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23555 }
23556 return resultobj;
23557 fail:
23558 return NULL;
23559 }
23560
23561
23562 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23563 PyObject *resultobj;
23564 char *kwnames[] = {
23565 NULL
23566 };
23567
23568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23569 {
23570 PyThreadState* __tstate = wxPyBeginAllowThreads();
23571 wxWakeUpIdle();
23572
23573 wxPyEndAllowThreads(__tstate);
23574 if (PyErr_Occurred()) SWIG_fail;
23575 }
23576 Py_INCREF(Py_None); resultobj = Py_None;
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj;
23585 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23586 wxEvent *arg2 = 0 ;
23587 PyObject * obj0 = 0 ;
23588 PyObject * obj1 = 0 ;
23589 char *kwnames[] = {
23590 (char *) "dest",(char *) "event", NULL
23591 };
23592
23593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23595 if (SWIG_arg_fail(1)) SWIG_fail;
23596 {
23597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23598 if (SWIG_arg_fail(2)) SWIG_fail;
23599 if (arg2 == NULL) {
23600 SWIG_null_ref("wxEvent");
23601 }
23602 if (SWIG_arg_fail(2)) SWIG_fail;
23603 }
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 wxPostEvent(arg1,*arg2);
23607
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 Py_INCREF(Py_None); resultobj = Py_None;
23612 return resultobj;
23613 fail:
23614 return NULL;
23615 }
23616
23617
23618 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23619 PyObject *resultobj;
23620 char *kwnames[] = {
23621 NULL
23622 };
23623
23624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 wxApp_CleanUp();
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 Py_INCREF(Py_None); resultobj = Py_None;
23633 return resultobj;
23634 fail:
23635 return NULL;
23636 }
23637
23638
23639 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23640 PyObject *resultobj;
23641 wxPyApp *result;
23642 char *kwnames[] = {
23643 NULL
23644 };
23645
23646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (wxPyApp *)wxPyGetApp();
23650
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 resultobj = wxPyMake_wxObject(result, 0);
23656 }
23657 return resultobj;
23658 fail:
23659 return NULL;
23660 }
23661
23662
23663 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23664 PyObject *resultobj;
23665 char *arg1 = (char *) 0 ;
23666 PyObject * obj0 = 0 ;
23667 char *kwnames[] = {
23668 (char *) "encoding", NULL
23669 };
23670
23671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23672 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23673 SWIG_arg_fail(1);SWIG_fail;
23674 }
23675 {
23676 PyThreadState* __tstate = wxPyBeginAllowThreads();
23677 wxSetDefaultPyEncoding((char const *)arg1);
23678
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 Py_INCREF(Py_None); resultobj = Py_None;
23683 return resultobj;
23684 fail:
23685 return NULL;
23686 }
23687
23688
23689 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23690 PyObject *resultobj;
23691 char *result;
23692 char *kwnames[] = {
23693 NULL
23694 };
23695
23696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23697 {
23698 PyThreadState* __tstate = wxPyBeginAllowThreads();
23699 result = (char *)wxGetDefaultPyEncoding();
23700
23701 wxPyEndAllowThreads(__tstate);
23702 if (PyErr_Occurred()) SWIG_fail;
23703 }
23704 resultobj = SWIG_FromCharPtr(result);
23705 return resultobj;
23706 fail:
23707 return NULL;
23708 }
23709
23710
23711 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23712 PyObject *resultobj;
23713 wxEventLoop *result;
23714 char *kwnames[] = {
23715 NULL
23716 };
23717
23718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 result = (wxEventLoop *)new wxEventLoop();
23722
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23734 PyObject *resultobj;
23735 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23736 PyObject * obj0 = 0 ;
23737 char *kwnames[] = {
23738 (char *) "self", NULL
23739 };
23740
23741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23743 if (SWIG_arg_fail(1)) SWIG_fail;
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 delete arg1;
23747
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 Py_INCREF(Py_None); resultobj = Py_None;
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj;
23760 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23761 int result;
23762 PyObject * obj0 = 0 ;
23763 char *kwnames[] = {
23764 (char *) "self", NULL
23765 };
23766
23767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = (int)(arg1)->Run();
23773
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 {
23778 resultobj = SWIG_From_int((int)(result));
23779 }
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj;
23788 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23789 int arg2 = (int) 0 ;
23790 PyObject * obj0 = 0 ;
23791 PyObject * obj1 = 0 ;
23792 char *kwnames[] = {
23793 (char *) "self",(char *) "rc", NULL
23794 };
23795
23796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23798 if (SWIG_arg_fail(1)) SWIG_fail;
23799 if (obj1) {
23800 {
23801 arg2 = (int)(SWIG_As_int(obj1));
23802 if (SWIG_arg_fail(2)) SWIG_fail;
23803 }
23804 }
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 (arg1)->Exit(arg2);
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 Py_INCREF(Py_None); resultobj = Py_None;
23813 return resultobj;
23814 fail:
23815 return NULL;
23816 }
23817
23818
23819 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj;
23821 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23822 bool result;
23823 PyObject * obj0 = 0 ;
23824 char *kwnames[] = {
23825 (char *) "self", NULL
23826 };
23827
23828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23830 if (SWIG_arg_fail(1)) SWIG_fail;
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = (bool)((wxEventLoop const *)arg1)->Pending();
23834
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 {
23839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23840 }
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23848 PyObject *resultobj;
23849 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23850 bool result;
23851 PyObject * obj0 = 0 ;
23852 char *kwnames[] = {
23853 (char *) "self", NULL
23854 };
23855
23856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23858 if (SWIG_arg_fail(1)) SWIG_fail;
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 result = (bool)(arg1)->Dispatch();
23862
23863 wxPyEndAllowThreads(__tstate);
23864 if (PyErr_Occurred()) SWIG_fail;
23865 }
23866 {
23867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23868 }
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23876 PyObject *resultobj;
23877 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23878 bool result;
23879 PyObject * obj0 = 0 ;
23880 char *kwnames[] = {
23881 (char *) "self", NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23886 if (SWIG_arg_fail(1)) SWIG_fail;
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 {
23895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23896 }
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23904 PyObject *resultobj;
23905 wxEventLoop *result;
23906 char *kwnames[] = {
23907 NULL
23908 };
23909
23910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 result = (wxEventLoop *)wxEventLoop::GetActive();
23914
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23926 PyObject *resultobj;
23927 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23928 PyObject * obj0 = 0 ;
23929 char *kwnames[] = {
23930 (char *) "loop", NULL
23931 };
23932
23933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23935 if (SWIG_arg_fail(1)) SWIG_fail;
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 wxEventLoop::SetActive(arg1);
23939
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 Py_INCREF(Py_None); resultobj = Py_None;
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23951 PyObject *obj;
23952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23953 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23954 Py_INCREF(obj);
23955 return Py_BuildValue((char *)"");
23956 }
23957 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23958 PyObject *resultobj;
23959 int arg1 = (int) 0 ;
23960 int arg2 = (int) 0 ;
23961 int arg3 = (int) 0 ;
23962 wxAcceleratorEntry *result;
23963 PyObject * obj0 = 0 ;
23964 PyObject * obj1 = 0 ;
23965 PyObject * obj2 = 0 ;
23966 char *kwnames[] = {
23967 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23968 };
23969
23970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23971 if (obj0) {
23972 {
23973 arg1 = (int)(SWIG_As_int(obj0));
23974 if (SWIG_arg_fail(1)) SWIG_fail;
23975 }
23976 }
23977 if (obj1) {
23978 {
23979 arg2 = (int)(SWIG_As_int(obj1));
23980 if (SWIG_arg_fail(2)) SWIG_fail;
23981 }
23982 }
23983 if (obj2) {
23984 {
23985 arg3 = (int)(SWIG_As_int(obj2));
23986 if (SWIG_arg_fail(3)) SWIG_fail;
23987 }
23988 }
23989 {
23990 PyThreadState* __tstate = wxPyBeginAllowThreads();
23991 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23992
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24004 PyObject *resultobj;
24005 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24006 PyObject * obj0 = 0 ;
24007 char *kwnames[] = {
24008 (char *) "self", NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24013 if (SWIG_arg_fail(1)) SWIG_fail;
24014 {
24015 PyThreadState* __tstate = wxPyBeginAllowThreads();
24016 delete arg1;
24017
24018 wxPyEndAllowThreads(__tstate);
24019 if (PyErr_Occurred()) SWIG_fail;
24020 }
24021 Py_INCREF(Py_None); resultobj = Py_None;
24022 return resultobj;
24023 fail:
24024 return NULL;
24025 }
24026
24027
24028 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24029 PyObject *resultobj;
24030 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24031 int arg2 ;
24032 int arg3 ;
24033 int arg4 ;
24034 PyObject * obj0 = 0 ;
24035 PyObject * obj1 = 0 ;
24036 PyObject * obj2 = 0 ;
24037 PyObject * obj3 = 0 ;
24038 char *kwnames[] = {
24039 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24040 };
24041
24042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24044 if (SWIG_arg_fail(1)) SWIG_fail;
24045 {
24046 arg2 = (int)(SWIG_As_int(obj1));
24047 if (SWIG_arg_fail(2)) SWIG_fail;
24048 }
24049 {
24050 arg3 = (int)(SWIG_As_int(obj2));
24051 if (SWIG_arg_fail(3)) SWIG_fail;
24052 }
24053 {
24054 arg4 = (int)(SWIG_As_int(obj3));
24055 if (SWIG_arg_fail(4)) SWIG_fail;
24056 }
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 (arg1)->Set(arg2,arg3,arg4);
24060
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 Py_INCREF(Py_None); resultobj = Py_None;
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj;
24073 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24074 int result;
24075 PyObject * obj0 = 0 ;
24076 char *kwnames[] = {
24077 (char *) "self", NULL
24078 };
24079
24080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24082 if (SWIG_arg_fail(1)) SWIG_fail;
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 result = (int)(arg1)->GetFlags();
24086
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 {
24091 resultobj = SWIG_From_int((int)(result));
24092 }
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24100 PyObject *resultobj;
24101 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24102 int result;
24103 PyObject * obj0 = 0 ;
24104 char *kwnames[] = {
24105 (char *) "self", NULL
24106 };
24107
24108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24110 if (SWIG_arg_fail(1)) SWIG_fail;
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 result = (int)(arg1)->GetKeyCode();
24114
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 {
24119 resultobj = SWIG_From_int((int)(result));
24120 }
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24128 PyObject *resultobj;
24129 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24130 int result;
24131 PyObject * obj0 = 0 ;
24132 char *kwnames[] = {
24133 (char *) "self", NULL
24134 };
24135
24136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24138 if (SWIG_arg_fail(1)) SWIG_fail;
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 result = (int)(arg1)->GetCommand();
24142
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 {
24147 resultobj = SWIG_From_int((int)(result));
24148 }
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24156 PyObject *obj;
24157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24158 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24159 Py_INCREF(obj);
24160 return Py_BuildValue((char *)"");
24161 }
24162 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24163 PyObject *resultobj;
24164 int arg1 ;
24165 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24166 wxAcceleratorTable *result;
24167 PyObject * obj0 = 0 ;
24168 char *kwnames[] = {
24169 (char *) "n", NULL
24170 };
24171
24172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24173 {
24174 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24175 if (arg2) arg1 = PyList_Size(obj0);
24176 else arg1 = 0;
24177 }
24178 {
24179 PyThreadState* __tstate = wxPyBeginAllowThreads();
24180 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24181
24182 wxPyEndAllowThreads(__tstate);
24183 if (PyErr_Occurred()) SWIG_fail;
24184 }
24185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24186 {
24187 delete [] arg2;
24188 }
24189 return resultobj;
24190 fail:
24191 {
24192 delete [] arg2;
24193 }
24194 return NULL;
24195 }
24196
24197
24198 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj;
24200 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24201 PyObject * obj0 = 0 ;
24202 char *kwnames[] = {
24203 (char *) "self", NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, 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_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj;
24225 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24226 bool result;
24227 PyObject * obj0 = 0 ;
24228 char *kwnames[] = {
24229 (char *) "self", NULL
24230 };
24231
24232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24234 if (SWIG_arg_fail(1)) SWIG_fail;
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24238
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 {
24243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24244 }
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24252 PyObject *obj;
24253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24254 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24255 Py_INCREF(obj);
24256 return Py_BuildValue((char *)"");
24257 }
24258 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24259 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24260 return 1;
24261 }
24262
24263
24264 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24265 PyObject *pyobj;
24266
24267 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24268 return pyobj;
24269 }
24270
24271
24272 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24273 PyObject *resultobj;
24274 wxString *arg1 = 0 ;
24275 wxAcceleratorEntry *result;
24276 bool temp1 = false ;
24277 PyObject * obj0 = 0 ;
24278 char *kwnames[] = {
24279 (char *) "label", NULL
24280 };
24281
24282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24283 {
24284 arg1 = wxString_in_helper(obj0);
24285 if (arg1 == NULL) SWIG_fail;
24286 temp1 = true;
24287 }
24288 {
24289 PyThreadState* __tstate = wxPyBeginAllowThreads();
24290 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24291
24292 wxPyEndAllowThreads(__tstate);
24293 if (PyErr_Occurred()) SWIG_fail;
24294 }
24295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24296 {
24297 if (temp1)
24298 delete arg1;
24299 }
24300 return resultobj;
24301 fail:
24302 {
24303 if (temp1)
24304 delete arg1;
24305 }
24306 return NULL;
24307 }
24308
24309
24310 static int _wrap_PanelNameStr_set(PyObject *) {
24311 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24312 return 1;
24313 }
24314
24315
24316 static PyObject *_wrap_PanelNameStr_get(void) {
24317 PyObject *pyobj;
24318
24319 {
24320 #if wxUSE_UNICODE
24321 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24322 #else
24323 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24324 #endif
24325 }
24326 return pyobj;
24327 }
24328
24329
24330 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24331 PyObject *resultobj;
24332 wxVisualAttributes *result;
24333 char *kwnames[] = {
24334 NULL
24335 };
24336
24337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 result = (wxVisualAttributes *)new_wxVisualAttributes();
24341
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24355 PyObject * obj0 = 0 ;
24356 char *kwnames[] = {
24357 (char *) "self", NULL
24358 };
24359
24360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24362 if (SWIG_arg_fail(1)) SWIG_fail;
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 delete_wxVisualAttributes(arg1);
24366
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 Py_INCREF(Py_None); resultobj = Py_None;
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj;
24379 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24380 wxFont *arg2 = (wxFont *) 0 ;
24381 PyObject * obj0 = 0 ;
24382 PyObject * obj1 = 0 ;
24383 char *kwnames[] = {
24384 (char *) "self",(char *) "font", NULL
24385 };
24386
24387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24389 if (SWIG_arg_fail(1)) SWIG_fail;
24390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24391 if (SWIG_arg_fail(2)) SWIG_fail;
24392 if (arg1) (arg1)->font = *arg2;
24393
24394 Py_INCREF(Py_None); resultobj = Py_None;
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24402 PyObject *resultobj;
24403 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24404 wxFont *result;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 result = (wxFont *)& ((arg1)->font);
24414
24415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24416 return resultobj;
24417 fail:
24418 return NULL;
24419 }
24420
24421
24422 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24423 PyObject *resultobj;
24424 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24425 wxColour *arg2 = (wxColour *) 0 ;
24426 PyObject * obj0 = 0 ;
24427 PyObject * obj1 = 0 ;
24428 char *kwnames[] = {
24429 (char *) "self",(char *) "colFg", NULL
24430 };
24431
24432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24434 if (SWIG_arg_fail(1)) SWIG_fail;
24435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24436 if (SWIG_arg_fail(2)) SWIG_fail;
24437 if (arg1) (arg1)->colFg = *arg2;
24438
24439 Py_INCREF(Py_None); resultobj = Py_None;
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24447 PyObject *resultobj;
24448 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24449 wxColour *result;
24450 PyObject * obj0 = 0 ;
24451 char *kwnames[] = {
24452 (char *) "self", NULL
24453 };
24454
24455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24457 if (SWIG_arg_fail(1)) SWIG_fail;
24458 result = (wxColour *)& ((arg1)->colFg);
24459
24460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj;
24469 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24470 wxColour *arg2 = (wxColour *) 0 ;
24471 PyObject * obj0 = 0 ;
24472 PyObject * obj1 = 0 ;
24473 char *kwnames[] = {
24474 (char *) "self",(char *) "colBg", NULL
24475 };
24476
24477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24479 if (SWIG_arg_fail(1)) SWIG_fail;
24480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24481 if (SWIG_arg_fail(2)) SWIG_fail;
24482 if (arg1) (arg1)->colBg = *arg2;
24483
24484 Py_INCREF(Py_None); resultobj = Py_None;
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj;
24493 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24494 wxColour *result;
24495 PyObject * obj0 = 0 ;
24496 char *kwnames[] = {
24497 (char *) "self", NULL
24498 };
24499
24500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24502 if (SWIG_arg_fail(1)) SWIG_fail;
24503 result = (wxColour *)& ((arg1)->colBg);
24504
24505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24506 return resultobj;
24507 fail:
24508 return NULL;
24509 }
24510
24511
24512 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24513 PyObject *obj;
24514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24515 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24516 Py_INCREF(obj);
24517 return Py_BuildValue((char *)"");
24518 }
24519 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24520 PyObject *resultobj;
24521 wxWindow *arg1 = (wxWindow *) 0 ;
24522 int arg2 = (int) (int)-1 ;
24523 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24524 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24525 wxSize const &arg4_defvalue = wxDefaultSize ;
24526 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24527 long arg5 = (long) 0 ;
24528 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24529 wxString *arg6 = (wxString *) &arg6_defvalue ;
24530 wxWindow *result;
24531 wxPoint temp3 ;
24532 wxSize temp4 ;
24533 bool temp6 = false ;
24534 PyObject * obj0 = 0 ;
24535 PyObject * obj1 = 0 ;
24536 PyObject * obj2 = 0 ;
24537 PyObject * obj3 = 0 ;
24538 PyObject * obj4 = 0 ;
24539 PyObject * obj5 = 0 ;
24540 char *kwnames[] = {
24541 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24542 };
24543
24544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24546 if (SWIG_arg_fail(1)) SWIG_fail;
24547 if (obj1) {
24548 {
24549 arg2 = (int const)(SWIG_As_int(obj1));
24550 if (SWIG_arg_fail(2)) SWIG_fail;
24551 }
24552 }
24553 if (obj2) {
24554 {
24555 arg3 = &temp3;
24556 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24557 }
24558 }
24559 if (obj3) {
24560 {
24561 arg4 = &temp4;
24562 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24563 }
24564 }
24565 if (obj4) {
24566 {
24567 arg5 = (long)(SWIG_As_long(obj4));
24568 if (SWIG_arg_fail(5)) SWIG_fail;
24569 }
24570 }
24571 if (obj5) {
24572 {
24573 arg6 = wxString_in_helper(obj5);
24574 if (arg6 == NULL) SWIG_fail;
24575 temp6 = true;
24576 }
24577 }
24578 {
24579 if (!wxPyCheckForApp()) SWIG_fail;
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24582
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24587 {
24588 if (temp6)
24589 delete arg6;
24590 }
24591 return resultobj;
24592 fail:
24593 {
24594 if (temp6)
24595 delete arg6;
24596 }
24597 return NULL;
24598 }
24599
24600
24601 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24602 PyObject *resultobj;
24603 wxWindow *result;
24604 char *kwnames[] = {
24605 NULL
24606 };
24607
24608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24609 {
24610 if (!wxPyCheckForApp()) SWIG_fail;
24611 PyThreadState* __tstate = wxPyBeginAllowThreads();
24612 result = (wxWindow *)new wxWindow();
24613
24614 wxPyEndAllowThreads(__tstate);
24615 if (PyErr_Occurred()) SWIG_fail;
24616 }
24617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24618 return resultobj;
24619 fail:
24620 return NULL;
24621 }
24622
24623
24624 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24625 PyObject *resultobj;
24626 wxWindow *arg1 = (wxWindow *) 0 ;
24627 wxWindow *arg2 = (wxWindow *) 0 ;
24628 int arg3 = (int) (int)-1 ;
24629 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24630 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24631 wxSize const &arg5_defvalue = wxDefaultSize ;
24632 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24633 long arg6 = (long) 0 ;
24634 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24635 wxString *arg7 = (wxString *) &arg7_defvalue ;
24636 bool result;
24637 wxPoint temp4 ;
24638 wxSize temp5 ;
24639 bool temp7 = false ;
24640 PyObject * obj0 = 0 ;
24641 PyObject * obj1 = 0 ;
24642 PyObject * obj2 = 0 ;
24643 PyObject * obj3 = 0 ;
24644 PyObject * obj4 = 0 ;
24645 PyObject * obj5 = 0 ;
24646 PyObject * obj6 = 0 ;
24647 char *kwnames[] = {
24648 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24649 };
24650
24651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24653 if (SWIG_arg_fail(1)) SWIG_fail;
24654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24655 if (SWIG_arg_fail(2)) SWIG_fail;
24656 if (obj2) {
24657 {
24658 arg3 = (int const)(SWIG_As_int(obj2));
24659 if (SWIG_arg_fail(3)) SWIG_fail;
24660 }
24661 }
24662 if (obj3) {
24663 {
24664 arg4 = &temp4;
24665 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24666 }
24667 }
24668 if (obj4) {
24669 {
24670 arg5 = &temp5;
24671 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24672 }
24673 }
24674 if (obj5) {
24675 {
24676 arg6 = (long)(SWIG_As_long(obj5));
24677 if (SWIG_arg_fail(6)) SWIG_fail;
24678 }
24679 }
24680 if (obj6) {
24681 {
24682 arg7 = wxString_in_helper(obj6);
24683 if (arg7 == NULL) SWIG_fail;
24684 temp7 = true;
24685 }
24686 }
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24690
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 {
24695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24696 }
24697 {
24698 if (temp7)
24699 delete arg7;
24700 }
24701 return resultobj;
24702 fail:
24703 {
24704 if (temp7)
24705 delete arg7;
24706 }
24707 return NULL;
24708 }
24709
24710
24711 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24712 PyObject *resultobj;
24713 wxWindow *arg1 = (wxWindow *) 0 ;
24714 bool arg2 = (bool) false ;
24715 bool result;
24716 PyObject * obj0 = 0 ;
24717 PyObject * obj1 = 0 ;
24718 char *kwnames[] = {
24719 (char *) "self",(char *) "force", NULL
24720 };
24721
24722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24724 if (SWIG_arg_fail(1)) SWIG_fail;
24725 if (obj1) {
24726 {
24727 arg2 = (bool)(SWIG_As_bool(obj1));
24728 if (SWIG_arg_fail(2)) SWIG_fail;
24729 }
24730 }
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 result = (bool)(arg1)->Close(arg2);
24734
24735 wxPyEndAllowThreads(__tstate);
24736 if (PyErr_Occurred()) SWIG_fail;
24737 }
24738 {
24739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24740 }
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj;
24749 wxWindow *arg1 = (wxWindow *) 0 ;
24750 bool result;
24751 PyObject * obj0 = 0 ;
24752 char *kwnames[] = {
24753 (char *) "self", NULL
24754 };
24755
24756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(1)) SWIG_fail;
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 result = (bool)(arg1)->Destroy();
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 {
24767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24768 }
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxWindow *arg1 = (wxWindow *) 0 ;
24778 bool result;
24779 PyObject * obj0 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (bool)(arg1)->DestroyChildren();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxWindow *arg1 = (wxWindow *) 0 ;
24806 bool result;
24807 PyObject * obj0 = 0 ;
24808 char *kwnames[] = {
24809 (char *) "self", NULL
24810 };
24811
24812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24814 if (SWIG_arg_fail(1)) SWIG_fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj;
24833 wxWindow *arg1 = (wxWindow *) 0 ;
24834 wxString *arg2 = 0 ;
24835 bool temp2 = false ;
24836 PyObject * obj0 = 0 ;
24837 PyObject * obj1 = 0 ;
24838 char *kwnames[] = {
24839 (char *) "self",(char *) "title", NULL
24840 };
24841
24842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24844 if (SWIG_arg_fail(1)) SWIG_fail;
24845 {
24846 arg2 = wxString_in_helper(obj1);
24847 if (arg2 == NULL) SWIG_fail;
24848 temp2 = true;
24849 }
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 (arg1)->SetTitle((wxString const &)*arg2);
24853
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 Py_INCREF(Py_None); resultobj = Py_None;
24858 {
24859 if (temp2)
24860 delete arg2;
24861 }
24862 return resultobj;
24863 fail:
24864 {
24865 if (temp2)
24866 delete arg2;
24867 }
24868 return NULL;
24869 }
24870
24871
24872 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24873 PyObject *resultobj;
24874 wxWindow *arg1 = (wxWindow *) 0 ;
24875 wxString result;
24876 PyObject * obj0 = 0 ;
24877 char *kwnames[] = {
24878 (char *) "self", NULL
24879 };
24880
24881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24883 if (SWIG_arg_fail(1)) SWIG_fail;
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 result = ((wxWindow const *)arg1)->GetTitle();
24887
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 {
24892 #if wxUSE_UNICODE
24893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24894 #else
24895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24896 #endif
24897 }
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj;
24906 wxWindow *arg1 = (wxWindow *) 0 ;
24907 wxString *arg2 = 0 ;
24908 bool temp2 = false ;
24909 PyObject * obj0 = 0 ;
24910 PyObject * obj1 = 0 ;
24911 char *kwnames[] = {
24912 (char *) "self",(char *) "label", NULL
24913 };
24914
24915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24917 if (SWIG_arg_fail(1)) SWIG_fail;
24918 {
24919 arg2 = wxString_in_helper(obj1);
24920 if (arg2 == NULL) SWIG_fail;
24921 temp2 = true;
24922 }
24923 {
24924 PyThreadState* __tstate = wxPyBeginAllowThreads();
24925 (arg1)->SetLabel((wxString const &)*arg2);
24926
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 Py_INCREF(Py_None); resultobj = Py_None;
24931 {
24932 if (temp2)
24933 delete arg2;
24934 }
24935 return resultobj;
24936 fail:
24937 {
24938 if (temp2)
24939 delete arg2;
24940 }
24941 return NULL;
24942 }
24943
24944
24945 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24946 PyObject *resultobj;
24947 wxWindow *arg1 = (wxWindow *) 0 ;
24948 wxString result;
24949 PyObject * obj0 = 0 ;
24950 char *kwnames[] = {
24951 (char *) "self", NULL
24952 };
24953
24954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24956 if (SWIG_arg_fail(1)) SWIG_fail;
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 result = ((wxWindow const *)arg1)->GetLabel();
24960
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 {
24965 #if wxUSE_UNICODE
24966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24967 #else
24968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24969 #endif
24970 }
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj;
24979 wxWindow *arg1 = (wxWindow *) 0 ;
24980 wxString *arg2 = 0 ;
24981 bool temp2 = false ;
24982 PyObject * obj0 = 0 ;
24983 PyObject * obj1 = 0 ;
24984 char *kwnames[] = {
24985 (char *) "self",(char *) "name", NULL
24986 };
24987
24988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24990 if (SWIG_arg_fail(1)) SWIG_fail;
24991 {
24992 arg2 = wxString_in_helper(obj1);
24993 if (arg2 == NULL) SWIG_fail;
24994 temp2 = true;
24995 }
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 (arg1)->SetName((wxString const &)*arg2);
24999
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 Py_INCREF(Py_None); resultobj = Py_None;
25004 {
25005 if (temp2)
25006 delete arg2;
25007 }
25008 return resultobj;
25009 fail:
25010 {
25011 if (temp2)
25012 delete arg2;
25013 }
25014 return NULL;
25015 }
25016
25017
25018 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25019 PyObject *resultobj;
25020 wxWindow *arg1 = (wxWindow *) 0 ;
25021 wxString result;
25022 PyObject * obj0 = 0 ;
25023 char *kwnames[] = {
25024 (char *) "self", NULL
25025 };
25026
25027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25029 if (SWIG_arg_fail(1)) SWIG_fail;
25030 {
25031 PyThreadState* __tstate = wxPyBeginAllowThreads();
25032 result = ((wxWindow const *)arg1)->GetName();
25033
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 {
25038 #if wxUSE_UNICODE
25039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25040 #else
25041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25042 #endif
25043 }
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj;
25052 wxWindow *arg1 = (wxWindow *) 0 ;
25053 wxWindowVariant arg2 ;
25054 PyObject * obj0 = 0 ;
25055 PyObject * obj1 = 0 ;
25056 char *kwnames[] = {
25057 (char *) "self",(char *) "variant", NULL
25058 };
25059
25060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25062 if (SWIG_arg_fail(1)) SWIG_fail;
25063 {
25064 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25065 if (SWIG_arg_fail(2)) SWIG_fail;
25066 }
25067 {
25068 PyThreadState* __tstate = wxPyBeginAllowThreads();
25069 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25070
25071 wxPyEndAllowThreads(__tstate);
25072 if (PyErr_Occurred()) SWIG_fail;
25073 }
25074 Py_INCREF(Py_None); resultobj = Py_None;
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj;
25083 wxWindow *arg1 = (wxWindow *) 0 ;
25084 wxWindowVariant result;
25085 PyObject * obj0 = 0 ;
25086 char *kwnames[] = {
25087 (char *) "self", NULL
25088 };
25089
25090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25092 if (SWIG_arg_fail(1)) SWIG_fail;
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25096
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 resultobj = SWIG_From_int((result));
25101 return resultobj;
25102 fail:
25103 return NULL;
25104 }
25105
25106
25107 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj;
25109 wxWindow *arg1 = (wxWindow *) 0 ;
25110 int arg2 ;
25111 PyObject * obj0 = 0 ;
25112 PyObject * obj1 = 0 ;
25113 char *kwnames[] = {
25114 (char *) "self",(char *) "winid", NULL
25115 };
25116
25117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25119 if (SWIG_arg_fail(1)) SWIG_fail;
25120 {
25121 arg2 = (int)(SWIG_As_int(obj1));
25122 if (SWIG_arg_fail(2)) SWIG_fail;
25123 }
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 (arg1)->SetId(arg2);
25127
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 Py_INCREF(Py_None); resultobj = Py_None;
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj;
25140 wxWindow *arg1 = (wxWindow *) 0 ;
25141 int result;
25142 PyObject * obj0 = 0 ;
25143 char *kwnames[] = {
25144 (char *) "self", NULL
25145 };
25146
25147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25149 if (SWIG_arg_fail(1)) SWIG_fail;
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 result = (int)((wxWindow const *)arg1)->GetId();
25153
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 resultobj = SWIG_From_int((int)(result));
25159 }
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25167 PyObject *resultobj;
25168 int result;
25169 char *kwnames[] = {
25170 NULL
25171 };
25172
25173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 result = (int)wxWindow::NewControlId();
25177
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 resultobj = SWIG_From_int((int)(result));
25183 }
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25191 PyObject *resultobj;
25192 int arg1 ;
25193 int result;
25194 PyObject * obj0 = 0 ;
25195 char *kwnames[] = {
25196 (char *) "winid", NULL
25197 };
25198
25199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25200 {
25201 arg1 = (int)(SWIG_As_int(obj0));
25202 if (SWIG_arg_fail(1)) SWIG_fail;
25203 }
25204 {
25205 PyThreadState* __tstate = wxPyBeginAllowThreads();
25206 result = (int)wxWindow::NextControlId(arg1);
25207
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 {
25212 resultobj = SWIG_From_int((int)(result));
25213 }
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25221 PyObject *resultobj;
25222 int arg1 ;
25223 int result;
25224 PyObject * obj0 = 0 ;
25225 char *kwnames[] = {
25226 (char *) "winid", NULL
25227 };
25228
25229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25230 {
25231 arg1 = (int)(SWIG_As_int(obj0));
25232 if (SWIG_arg_fail(1)) SWIG_fail;
25233 }
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (int)wxWindow::PrevControlId(arg1);
25237
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 {
25242 resultobj = SWIG_From_int((int)(result));
25243 }
25244 return resultobj;
25245 fail:
25246 return NULL;
25247 }
25248
25249
25250 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj;
25252 wxWindow *arg1 = (wxWindow *) 0 ;
25253 wxSize *arg2 = 0 ;
25254 wxSize temp2 ;
25255 PyObject * obj0 = 0 ;
25256 PyObject * obj1 = 0 ;
25257 char *kwnames[] = {
25258 (char *) "self",(char *) "size", NULL
25259 };
25260
25261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25263 if (SWIG_arg_fail(1)) SWIG_fail;
25264 {
25265 arg2 = &temp2;
25266 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25267 }
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 (arg1)->SetSize((wxSize const &)*arg2);
25271
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 Py_INCREF(Py_None); resultobj = Py_None;
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj;
25284 wxWindow *arg1 = (wxWindow *) 0 ;
25285 int arg2 ;
25286 int arg3 ;
25287 int arg4 ;
25288 int arg5 ;
25289 int arg6 = (int) wxSIZE_AUTO ;
25290 PyObject * obj0 = 0 ;
25291 PyObject * obj1 = 0 ;
25292 PyObject * obj2 = 0 ;
25293 PyObject * obj3 = 0 ;
25294 PyObject * obj4 = 0 ;
25295 PyObject * obj5 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25302 if (SWIG_arg_fail(1)) SWIG_fail;
25303 {
25304 arg2 = (int)(SWIG_As_int(obj1));
25305 if (SWIG_arg_fail(2)) SWIG_fail;
25306 }
25307 {
25308 arg3 = (int)(SWIG_As_int(obj2));
25309 if (SWIG_arg_fail(3)) SWIG_fail;
25310 }
25311 {
25312 arg4 = (int)(SWIG_As_int(obj3));
25313 if (SWIG_arg_fail(4)) SWIG_fail;
25314 }
25315 {
25316 arg5 = (int)(SWIG_As_int(obj4));
25317 if (SWIG_arg_fail(5)) SWIG_fail;
25318 }
25319 if (obj5) {
25320 {
25321 arg6 = (int)(SWIG_As_int(obj5));
25322 if (SWIG_arg_fail(6)) SWIG_fail;
25323 }
25324 }
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25328
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 Py_INCREF(Py_None); resultobj = Py_None;
25333 return resultobj;
25334 fail:
25335 return NULL;
25336 }
25337
25338
25339 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25340 PyObject *resultobj;
25341 wxWindow *arg1 = (wxWindow *) 0 ;
25342 wxRect *arg2 = 0 ;
25343 int arg3 = (int) wxSIZE_AUTO ;
25344 wxRect temp2 ;
25345 PyObject * obj0 = 0 ;
25346 PyObject * obj1 = 0 ;
25347 PyObject * obj2 = 0 ;
25348 char *kwnames[] = {
25349 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25350 };
25351
25352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25354 if (SWIG_arg_fail(1)) SWIG_fail;
25355 {
25356 arg2 = &temp2;
25357 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25358 }
25359 if (obj2) {
25360 {
25361 arg3 = (int)(SWIG_As_int(obj2));
25362 if (SWIG_arg_fail(3)) SWIG_fail;
25363 }
25364 }
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25368
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 Py_INCREF(Py_None); resultobj = Py_None;
25373 return resultobj;
25374 fail:
25375 return NULL;
25376 }
25377
25378
25379 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25380 PyObject *resultobj;
25381 wxWindow *arg1 = (wxWindow *) 0 ;
25382 int arg2 ;
25383 int arg3 ;
25384 PyObject * obj0 = 0 ;
25385 PyObject * obj1 = 0 ;
25386 PyObject * obj2 = 0 ;
25387 char *kwnames[] = {
25388 (char *) "self",(char *) "width",(char *) "height", NULL
25389 };
25390
25391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25393 if (SWIG_arg_fail(1)) SWIG_fail;
25394 {
25395 arg2 = (int)(SWIG_As_int(obj1));
25396 if (SWIG_arg_fail(2)) SWIG_fail;
25397 }
25398 {
25399 arg3 = (int)(SWIG_As_int(obj2));
25400 if (SWIG_arg_fail(3)) SWIG_fail;
25401 }
25402 {
25403 PyThreadState* __tstate = wxPyBeginAllowThreads();
25404 (arg1)->SetSize(arg2,arg3);
25405
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 Py_INCREF(Py_None); resultobj = Py_None;
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25417 PyObject *resultobj;
25418 wxWindow *arg1 = (wxWindow *) 0 ;
25419 wxPoint *arg2 = 0 ;
25420 int arg3 = (int) wxSIZE_USE_EXISTING ;
25421 wxPoint temp2 ;
25422 PyObject * obj0 = 0 ;
25423 PyObject * obj1 = 0 ;
25424 PyObject * obj2 = 0 ;
25425 char *kwnames[] = {
25426 (char *) "self",(char *) "pt",(char *) "flags", NULL
25427 };
25428
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25431 if (SWIG_arg_fail(1)) SWIG_fail;
25432 {
25433 arg2 = &temp2;
25434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25435 }
25436 if (obj2) {
25437 {
25438 arg3 = (int)(SWIG_As_int(obj2));
25439 if (SWIG_arg_fail(3)) SWIG_fail;
25440 }
25441 }
25442 {
25443 PyThreadState* __tstate = wxPyBeginAllowThreads();
25444 (arg1)->Move((wxPoint const &)*arg2,arg3);
25445
25446 wxPyEndAllowThreads(__tstate);
25447 if (PyErr_Occurred()) SWIG_fail;
25448 }
25449 Py_INCREF(Py_None); resultobj = Py_None;
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25457 PyObject *resultobj;
25458 wxWindow *arg1 = (wxWindow *) 0 ;
25459 int arg2 ;
25460 int arg3 ;
25461 int arg4 = (int) wxSIZE_USE_EXISTING ;
25462 PyObject * obj0 = 0 ;
25463 PyObject * obj1 = 0 ;
25464 PyObject * obj2 = 0 ;
25465 PyObject * obj3 = 0 ;
25466 char *kwnames[] = {
25467 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25468 };
25469
25470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25472 if (SWIG_arg_fail(1)) SWIG_fail;
25473 {
25474 arg2 = (int)(SWIG_As_int(obj1));
25475 if (SWIG_arg_fail(2)) SWIG_fail;
25476 }
25477 {
25478 arg3 = (int)(SWIG_As_int(obj2));
25479 if (SWIG_arg_fail(3)) SWIG_fail;
25480 }
25481 if (obj3) {
25482 {
25483 arg4 = (int)(SWIG_As_int(obj3));
25484 if (SWIG_arg_fail(4)) SWIG_fail;
25485 }
25486 }
25487 {
25488 PyThreadState* __tstate = wxPyBeginAllowThreads();
25489 (arg1)->Move(arg2,arg3,arg4);
25490
25491 wxPyEndAllowThreads(__tstate);
25492 if (PyErr_Occurred()) SWIG_fail;
25493 }
25494 Py_INCREF(Py_None); resultobj = Py_None;
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25502 PyObject *resultobj;
25503 wxWindow *arg1 = (wxWindow *) 0 ;
25504 wxSize const &arg2_defvalue = wxDefaultSize ;
25505 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25506 wxSize temp2 ;
25507 PyObject * obj0 = 0 ;
25508 PyObject * obj1 = 0 ;
25509 char *kwnames[] = {
25510 (char *) "self",(char *) "size", NULL
25511 };
25512
25513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25515 if (SWIG_arg_fail(1)) SWIG_fail;
25516 if (obj1) {
25517 {
25518 arg2 = &temp2;
25519 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25520 }
25521 }
25522 {
25523 PyThreadState* __tstate = wxPyBeginAllowThreads();
25524 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25525
25526 wxPyEndAllowThreads(__tstate);
25527 if (PyErr_Occurred()) SWIG_fail;
25528 }
25529 Py_INCREF(Py_None); resultobj = Py_None;
25530 return resultobj;
25531 fail:
25532 return NULL;
25533 }
25534
25535
25536 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25537 PyObject *resultobj;
25538 wxWindow *arg1 = (wxWindow *) 0 ;
25539 PyObject * obj0 = 0 ;
25540 char *kwnames[] = {
25541 (char *) "self", NULL
25542 };
25543
25544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25546 if (SWIG_arg_fail(1)) SWIG_fail;
25547 {
25548 PyThreadState* __tstate = wxPyBeginAllowThreads();
25549 (arg1)->Raise();
25550
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 Py_INCREF(Py_None); resultobj = Py_None;
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj;
25563 wxWindow *arg1 = (wxWindow *) 0 ;
25564 PyObject * obj0 = 0 ;
25565 char *kwnames[] = {
25566 (char *) "self", NULL
25567 };
25568
25569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25571 if (SWIG_arg_fail(1)) SWIG_fail;
25572 {
25573 PyThreadState* __tstate = wxPyBeginAllowThreads();
25574 (arg1)->Lower();
25575
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 Py_INCREF(Py_None); resultobj = Py_None;
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25587 PyObject *resultobj;
25588 wxWindow *arg1 = (wxWindow *) 0 ;
25589 wxSize *arg2 = 0 ;
25590 wxSize temp2 ;
25591 PyObject * obj0 = 0 ;
25592 PyObject * obj1 = 0 ;
25593 char *kwnames[] = {
25594 (char *) "self",(char *) "size", NULL
25595 };
25596
25597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25599 if (SWIG_arg_fail(1)) SWIG_fail;
25600 {
25601 arg2 = &temp2;
25602 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25603 }
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 (arg1)->SetClientSize((wxSize const &)*arg2);
25607
25608 wxPyEndAllowThreads(__tstate);
25609 if (PyErr_Occurred()) SWIG_fail;
25610 }
25611 Py_INCREF(Py_None); resultobj = Py_None;
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25619 PyObject *resultobj;
25620 wxWindow *arg1 = (wxWindow *) 0 ;
25621 int arg2 ;
25622 int arg3 ;
25623 PyObject * obj0 = 0 ;
25624 PyObject * obj1 = 0 ;
25625 PyObject * obj2 = 0 ;
25626 char *kwnames[] = {
25627 (char *) "self",(char *) "width",(char *) "height", NULL
25628 };
25629
25630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25632 if (SWIG_arg_fail(1)) SWIG_fail;
25633 {
25634 arg2 = (int)(SWIG_As_int(obj1));
25635 if (SWIG_arg_fail(2)) SWIG_fail;
25636 }
25637 {
25638 arg3 = (int)(SWIG_As_int(obj2));
25639 if (SWIG_arg_fail(3)) SWIG_fail;
25640 }
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 (arg1)->SetClientSize(arg2,arg3);
25644
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 Py_INCREF(Py_None); resultobj = Py_None;
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 wxWindow *arg1 = (wxWindow *) 0 ;
25658 wxRect *arg2 = 0 ;
25659 wxRect temp2 ;
25660 PyObject * obj0 = 0 ;
25661 PyObject * obj1 = 0 ;
25662 char *kwnames[] = {
25663 (char *) "self",(char *) "rect", NULL
25664 };
25665
25666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25668 if (SWIG_arg_fail(1)) SWIG_fail;
25669 {
25670 arg2 = &temp2;
25671 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25672 }
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 (arg1)->SetClientSize((wxRect const &)*arg2);
25676
25677 wxPyEndAllowThreads(__tstate);
25678 if (PyErr_Occurred()) SWIG_fail;
25679 }
25680 Py_INCREF(Py_None); resultobj = Py_None;
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj;
25689 wxWindow *arg1 = (wxWindow *) 0 ;
25690 wxPoint result;
25691 PyObject * obj0 = 0 ;
25692 char *kwnames[] = {
25693 (char *) "self", NULL
25694 };
25695
25696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25698 if (SWIG_arg_fail(1)) SWIG_fail;
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = (arg1)->GetPosition();
25702
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 {
25707 wxPoint * resultptr;
25708 resultptr = new wxPoint((wxPoint &)(result));
25709 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25710 }
25711 return resultobj;
25712 fail:
25713 return NULL;
25714 }
25715
25716
25717 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25718 PyObject *resultobj;
25719 wxWindow *arg1 = (wxWindow *) 0 ;
25720 int *arg2 = (int *) 0 ;
25721 int *arg3 = (int *) 0 ;
25722 int temp2 ;
25723 int res2 = 0 ;
25724 int temp3 ;
25725 int res3 = 0 ;
25726 PyObject * obj0 = 0 ;
25727 char *kwnames[] = {
25728 (char *) "self", NULL
25729 };
25730
25731 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25732 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(1)) SWIG_fail;
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 (arg1)->GetPosition(arg2,arg3);
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 Py_INCREF(Py_None); resultobj = Py_None;
25744 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25745 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25746 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25747 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25748 return resultobj;
25749 fail:
25750 return NULL;
25751 }
25752
25753
25754 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25755 PyObject *resultobj;
25756 wxWindow *arg1 = (wxWindow *) 0 ;
25757 wxSize result;
25758 PyObject * obj0 = 0 ;
25759 char *kwnames[] = {
25760 (char *) "self", NULL
25761 };
25762
25763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25765 if (SWIG_arg_fail(1)) SWIG_fail;
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 result = ((wxWindow const *)arg1)->GetSize();
25769
25770 wxPyEndAllowThreads(__tstate);
25771 if (PyErr_Occurred()) SWIG_fail;
25772 }
25773 {
25774 wxSize * resultptr;
25775 resultptr = new wxSize((wxSize &)(result));
25776 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25777 }
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25785 PyObject *resultobj;
25786 wxWindow *arg1 = (wxWindow *) 0 ;
25787 int *arg2 = (int *) 0 ;
25788 int *arg3 = (int *) 0 ;
25789 int temp2 ;
25790 int res2 = 0 ;
25791 int temp3 ;
25792 int res3 = 0 ;
25793 PyObject * obj0 = 0 ;
25794 char *kwnames[] = {
25795 (char *) "self", NULL
25796 };
25797
25798 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25799 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25802 if (SWIG_arg_fail(1)) SWIG_fail;
25803 {
25804 PyThreadState* __tstate = wxPyBeginAllowThreads();
25805 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25806
25807 wxPyEndAllowThreads(__tstate);
25808 if (PyErr_Occurred()) SWIG_fail;
25809 }
25810 Py_INCREF(Py_None); resultobj = Py_None;
25811 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25812 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25813 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25814 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25822 PyObject *resultobj;
25823 wxWindow *arg1 = (wxWindow *) 0 ;
25824 wxRect result;
25825 PyObject * obj0 = 0 ;
25826 char *kwnames[] = {
25827 (char *) "self", NULL
25828 };
25829
25830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25832 if (SWIG_arg_fail(1)) SWIG_fail;
25833 {
25834 PyThreadState* __tstate = wxPyBeginAllowThreads();
25835 result = ((wxWindow const *)arg1)->GetRect();
25836
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 {
25841 wxRect * resultptr;
25842 resultptr = new wxRect((wxRect &)(result));
25843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25844 }
25845 return resultobj;
25846 fail:
25847 return NULL;
25848 }
25849
25850
25851 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25852 PyObject *resultobj;
25853 wxWindow *arg1 = (wxWindow *) 0 ;
25854 wxSize result;
25855 PyObject * obj0 = 0 ;
25856 char *kwnames[] = {
25857 (char *) "self", NULL
25858 };
25859
25860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25862 if (SWIG_arg_fail(1)) SWIG_fail;
25863 {
25864 PyThreadState* __tstate = wxPyBeginAllowThreads();
25865 result = ((wxWindow const *)arg1)->GetClientSize();
25866
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 {
25871 wxSize * resultptr;
25872 resultptr = new wxSize((wxSize &)(result));
25873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25874 }
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj;
25883 wxWindow *arg1 = (wxWindow *) 0 ;
25884 int *arg2 = (int *) 0 ;
25885 int *arg3 = (int *) 0 ;
25886 int temp2 ;
25887 int res2 = 0 ;
25888 int temp3 ;
25889 int res3 = 0 ;
25890 PyObject * obj0 = 0 ;
25891 char *kwnames[] = {
25892 (char *) "self", NULL
25893 };
25894
25895 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25896 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25899 if (SWIG_arg_fail(1)) SWIG_fail;
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25903
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 Py_INCREF(Py_None); resultobj = Py_None;
25908 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25909 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25910 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25911 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj;
25920 wxWindow *arg1 = (wxWindow *) 0 ;
25921 wxPoint result;
25922 PyObject * obj0 = 0 ;
25923 char *kwnames[] = {
25924 (char *) "self", NULL
25925 };
25926
25927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25929 if (SWIG_arg_fail(1)) SWIG_fail;
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25933
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 {
25938 wxPoint * resultptr;
25939 resultptr = new wxPoint((wxPoint &)(result));
25940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25941 }
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxWindow *arg1 = (wxWindow *) 0 ;
25951 wxRect result;
25952 PyObject * obj0 = 0 ;
25953 char *kwnames[] = {
25954 (char *) "self", NULL
25955 };
25956
25957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25959 if (SWIG_arg_fail(1)) SWIG_fail;
25960 {
25961 PyThreadState* __tstate = wxPyBeginAllowThreads();
25962 result = ((wxWindow const *)arg1)->GetClientRect();
25963
25964 wxPyEndAllowThreads(__tstate);
25965 if (PyErr_Occurred()) SWIG_fail;
25966 }
25967 {
25968 wxRect * resultptr;
25969 resultptr = new wxRect((wxRect &)(result));
25970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25971 }
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj;
25980 wxWindow *arg1 = (wxWindow *) 0 ;
25981 wxSize result;
25982 PyObject * obj0 = 0 ;
25983 char *kwnames[] = {
25984 (char *) "self", NULL
25985 };
25986
25987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25989 if (SWIG_arg_fail(1)) SWIG_fail;
25990 {
25991 PyThreadState* __tstate = wxPyBeginAllowThreads();
25992 result = ((wxWindow const *)arg1)->GetBestSize();
25993
25994 wxPyEndAllowThreads(__tstate);
25995 if (PyErr_Occurred()) SWIG_fail;
25996 }
25997 {
25998 wxSize * resultptr;
25999 resultptr = new wxSize((wxSize &)(result));
26000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26001 }
26002 return resultobj;
26003 fail:
26004 return NULL;
26005 }
26006
26007
26008 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj;
26010 wxWindow *arg1 = (wxWindow *) 0 ;
26011 int *arg2 = (int *) 0 ;
26012 int *arg3 = (int *) 0 ;
26013 int temp2 ;
26014 int res2 = 0 ;
26015 int temp3 ;
26016 int res3 = 0 ;
26017 PyObject * obj0 = 0 ;
26018 char *kwnames[] = {
26019 (char *) "self", NULL
26020 };
26021
26022 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26023 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26026 if (SWIG_arg_fail(1)) SWIG_fail;
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26030
26031 wxPyEndAllowThreads(__tstate);
26032 if (PyErr_Occurred()) SWIG_fail;
26033 }
26034 Py_INCREF(Py_None); resultobj = Py_None;
26035 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26036 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26037 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26038 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj;
26047 wxWindow *arg1 = (wxWindow *) 0 ;
26048 PyObject * obj0 = 0 ;
26049 char *kwnames[] = {
26050 (char *) "self", NULL
26051 };
26052
26053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26055 if (SWIG_arg_fail(1)) SWIG_fail;
26056 {
26057 PyThreadState* __tstate = wxPyBeginAllowThreads();
26058 (arg1)->InvalidateBestSize();
26059
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 Py_INCREF(Py_None); resultobj = Py_None;
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj;
26072 wxWindow *arg1 = (wxWindow *) 0 ;
26073 wxSize result;
26074 PyObject * obj0 = 0 ;
26075 char *kwnames[] = {
26076 (char *) "self", NULL
26077 };
26078
26079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26081 if (SWIG_arg_fail(1)) SWIG_fail;
26082 {
26083 PyThreadState* __tstate = wxPyBeginAllowThreads();
26084 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 {
26090 wxSize * resultptr;
26091 resultptr = new wxSize((wxSize &)(result));
26092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26093 }
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj;
26102 wxWindow *arg1 = (wxWindow *) 0 ;
26103 wxSize result;
26104 PyObject * obj0 = 0 ;
26105 char *kwnames[] = {
26106 (char *) "self", NULL
26107 };
26108
26109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26111 if (SWIG_arg_fail(1)) SWIG_fail;
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26115
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 {
26120 wxSize * resultptr;
26121 resultptr = new wxSize((wxSize &)(result));
26122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26123 }
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26131 PyObject *resultobj;
26132 wxWindow *arg1 = (wxWindow *) 0 ;
26133 int arg2 = (int) wxBOTH ;
26134 PyObject * obj0 = 0 ;
26135 PyObject * obj1 = 0 ;
26136 char *kwnames[] = {
26137 (char *) "self",(char *) "direction", NULL
26138 };
26139
26140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26142 if (SWIG_arg_fail(1)) SWIG_fail;
26143 if (obj1) {
26144 {
26145 arg2 = (int)(SWIG_As_int(obj1));
26146 if (SWIG_arg_fail(2)) SWIG_fail;
26147 }
26148 }
26149 {
26150 PyThreadState* __tstate = wxPyBeginAllowThreads();
26151 (arg1)->Center(arg2);
26152
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 Py_INCREF(Py_None); resultobj = Py_None;
26157 return resultobj;
26158 fail:
26159 return NULL;
26160 }
26161
26162
26163 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26164 PyObject *resultobj;
26165 wxWindow *arg1 = (wxWindow *) 0 ;
26166 int arg2 = (int) wxBOTH ;
26167 PyObject * obj0 = 0 ;
26168 PyObject * obj1 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self",(char *) "dir", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 if (obj1) {
26177 {
26178 arg2 = (int)(SWIG_As_int(obj1));
26179 if (SWIG_arg_fail(2)) SWIG_fail;
26180 }
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 (arg1)->CenterOnScreen(arg2);
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 Py_INCREF(Py_None); resultobj = Py_None;
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26197 PyObject *resultobj;
26198 wxWindow *arg1 = (wxWindow *) 0 ;
26199 int arg2 = (int) wxBOTH ;
26200 PyObject * obj0 = 0 ;
26201 PyObject * obj1 = 0 ;
26202 char *kwnames[] = {
26203 (char *) "self",(char *) "dir", NULL
26204 };
26205
26206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26208 if (SWIG_arg_fail(1)) SWIG_fail;
26209 if (obj1) {
26210 {
26211 arg2 = (int)(SWIG_As_int(obj1));
26212 if (SWIG_arg_fail(2)) SWIG_fail;
26213 }
26214 }
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 (arg1)->CenterOnParent(arg2);
26218
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 Py_INCREF(Py_None); resultobj = Py_None;
26223 return resultobj;
26224 fail:
26225 return NULL;
26226 }
26227
26228
26229 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26230 PyObject *resultobj;
26231 wxWindow *arg1 = (wxWindow *) 0 ;
26232 PyObject * obj0 = 0 ;
26233 char *kwnames[] = {
26234 (char *) "self", NULL
26235 };
26236
26237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26239 if (SWIG_arg_fail(1)) SWIG_fail;
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 (arg1)->Fit();
26243
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 Py_INCREF(Py_None); resultobj = Py_None;
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26255 PyObject *resultobj;
26256 wxWindow *arg1 = (wxWindow *) 0 ;
26257 PyObject * obj0 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self", NULL
26260 };
26261
26262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26264 if (SWIG_arg_fail(1)) SWIG_fail;
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 (arg1)->FitInside();
26268
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 Py_INCREF(Py_None); resultobj = Py_None;
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26280 PyObject *resultobj;
26281 wxWindow *arg1 = (wxWindow *) 0 ;
26282 int arg2 ;
26283 int arg3 ;
26284 int arg4 = (int) -1 ;
26285 int arg5 = (int) -1 ;
26286 int arg6 = (int) -1 ;
26287 int arg7 = (int) -1 ;
26288 PyObject * obj0 = 0 ;
26289 PyObject * obj1 = 0 ;
26290 PyObject * obj2 = 0 ;
26291 PyObject * obj3 = 0 ;
26292 PyObject * obj4 = 0 ;
26293 PyObject * obj5 = 0 ;
26294 PyObject * obj6 = 0 ;
26295 char *kwnames[] = {
26296 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26297 };
26298
26299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26301 if (SWIG_arg_fail(1)) SWIG_fail;
26302 {
26303 arg2 = (int)(SWIG_As_int(obj1));
26304 if (SWIG_arg_fail(2)) SWIG_fail;
26305 }
26306 {
26307 arg3 = (int)(SWIG_As_int(obj2));
26308 if (SWIG_arg_fail(3)) SWIG_fail;
26309 }
26310 if (obj3) {
26311 {
26312 arg4 = (int)(SWIG_As_int(obj3));
26313 if (SWIG_arg_fail(4)) SWIG_fail;
26314 }
26315 }
26316 if (obj4) {
26317 {
26318 arg5 = (int)(SWIG_As_int(obj4));
26319 if (SWIG_arg_fail(5)) SWIG_fail;
26320 }
26321 }
26322 if (obj5) {
26323 {
26324 arg6 = (int)(SWIG_As_int(obj5));
26325 if (SWIG_arg_fail(6)) SWIG_fail;
26326 }
26327 }
26328 if (obj6) {
26329 {
26330 arg7 = (int)(SWIG_As_int(obj6));
26331 if (SWIG_arg_fail(7)) SWIG_fail;
26332 }
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26337
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 Py_INCREF(Py_None); resultobj = Py_None;
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26349 PyObject *resultobj;
26350 wxWindow *arg1 = (wxWindow *) 0 ;
26351 wxSize *arg2 = 0 ;
26352 wxSize const &arg3_defvalue = wxDefaultSize ;
26353 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26354 wxSize const &arg4_defvalue = wxDefaultSize ;
26355 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26356 wxSize temp2 ;
26357 wxSize temp3 ;
26358 wxSize temp4 ;
26359 PyObject * obj0 = 0 ;
26360 PyObject * obj1 = 0 ;
26361 PyObject * obj2 = 0 ;
26362 PyObject * obj3 = 0 ;
26363 char *kwnames[] = {
26364 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26365 };
26366
26367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26369 if (SWIG_arg_fail(1)) SWIG_fail;
26370 {
26371 arg2 = &temp2;
26372 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26373 }
26374 if (obj2) {
26375 {
26376 arg3 = &temp3;
26377 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26378 }
26379 }
26380 if (obj3) {
26381 {
26382 arg4 = &temp4;
26383 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26384 }
26385 }
26386 {
26387 PyThreadState* __tstate = wxPyBeginAllowThreads();
26388 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26389
26390 wxPyEndAllowThreads(__tstate);
26391 if (PyErr_Occurred()) SWIG_fail;
26392 }
26393 Py_INCREF(Py_None); resultobj = Py_None;
26394 return resultobj;
26395 fail:
26396 return NULL;
26397 }
26398
26399
26400 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26401 PyObject *resultobj;
26402 wxWindow *arg1 = (wxWindow *) 0 ;
26403 int arg2 ;
26404 int arg3 ;
26405 int arg4 = (int) -1 ;
26406 int arg5 = (int) -1 ;
26407 PyObject * obj0 = 0 ;
26408 PyObject * obj1 = 0 ;
26409 PyObject * obj2 = 0 ;
26410 PyObject * obj3 = 0 ;
26411 PyObject * obj4 = 0 ;
26412 char *kwnames[] = {
26413 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26414 };
26415
26416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26418 if (SWIG_arg_fail(1)) SWIG_fail;
26419 {
26420 arg2 = (int)(SWIG_As_int(obj1));
26421 if (SWIG_arg_fail(2)) SWIG_fail;
26422 }
26423 {
26424 arg3 = (int)(SWIG_As_int(obj2));
26425 if (SWIG_arg_fail(3)) SWIG_fail;
26426 }
26427 if (obj3) {
26428 {
26429 arg4 = (int)(SWIG_As_int(obj3));
26430 if (SWIG_arg_fail(4)) SWIG_fail;
26431 }
26432 }
26433 if (obj4) {
26434 {
26435 arg5 = (int)(SWIG_As_int(obj4));
26436 if (SWIG_arg_fail(5)) SWIG_fail;
26437 }
26438 }
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 Py_INCREF(Py_None); resultobj = Py_None;
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26454 PyObject *resultobj;
26455 wxWindow *arg1 = (wxWindow *) 0 ;
26456 wxSize *arg2 = 0 ;
26457 wxSize const &arg3_defvalue = wxDefaultSize ;
26458 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26459 wxSize temp2 ;
26460 wxSize temp3 ;
26461 PyObject * obj0 = 0 ;
26462 PyObject * obj1 = 0 ;
26463 PyObject * obj2 = 0 ;
26464 char *kwnames[] = {
26465 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26466 };
26467
26468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26470 if (SWIG_arg_fail(1)) SWIG_fail;
26471 {
26472 arg2 = &temp2;
26473 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26474 }
26475 if (obj2) {
26476 {
26477 arg3 = &temp3;
26478 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26479 }
26480 }
26481 {
26482 PyThreadState* __tstate = wxPyBeginAllowThreads();
26483 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26484
26485 wxPyEndAllowThreads(__tstate);
26486 if (PyErr_Occurred()) SWIG_fail;
26487 }
26488 Py_INCREF(Py_None); resultobj = Py_None;
26489 return resultobj;
26490 fail:
26491 return NULL;
26492 }
26493
26494
26495 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26496 PyObject *resultobj;
26497 wxWindow *arg1 = (wxWindow *) 0 ;
26498 wxSize result;
26499 PyObject * obj0 = 0 ;
26500 char *kwnames[] = {
26501 (char *) "self", NULL
26502 };
26503
26504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26506 if (SWIG_arg_fail(1)) SWIG_fail;
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = ((wxWindow const *)arg1)->GetMaxSize();
26510
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 {
26515 wxSize * resultptr;
26516 resultptr = new wxSize((wxSize &)(result));
26517 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26518 }
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26526 PyObject *resultobj;
26527 wxWindow *arg1 = (wxWindow *) 0 ;
26528 wxSize result;
26529 PyObject * obj0 = 0 ;
26530 char *kwnames[] = {
26531 (char *) "self", NULL
26532 };
26533
26534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26536 if (SWIG_arg_fail(1)) SWIG_fail;
26537 {
26538 PyThreadState* __tstate = wxPyBeginAllowThreads();
26539 result = ((wxWindow const *)arg1)->GetMinSize();
26540
26541 wxPyEndAllowThreads(__tstate);
26542 if (PyErr_Occurred()) SWIG_fail;
26543 }
26544 {
26545 wxSize * resultptr;
26546 resultptr = new wxSize((wxSize &)(result));
26547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26548 }
26549 return resultobj;
26550 fail:
26551 return NULL;
26552 }
26553
26554
26555 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26556 PyObject *resultobj;
26557 wxWindow *arg1 = (wxWindow *) 0 ;
26558 wxSize *arg2 = 0 ;
26559 wxSize temp2 ;
26560 PyObject * obj0 = 0 ;
26561 PyObject * obj1 = 0 ;
26562 char *kwnames[] = {
26563 (char *) "self",(char *) "minSize", NULL
26564 };
26565
26566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26568 if (SWIG_arg_fail(1)) SWIG_fail;
26569 {
26570 arg2 = &temp2;
26571 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26572 }
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 (arg1)->SetMinSize((wxSize const &)*arg2);
26576
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 Py_INCREF(Py_None); resultobj = Py_None;
26581 return resultobj;
26582 fail:
26583 return NULL;
26584 }
26585
26586
26587 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26588 PyObject *resultobj;
26589 wxWindow *arg1 = (wxWindow *) 0 ;
26590 wxSize *arg2 = 0 ;
26591 wxSize temp2 ;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594 char *kwnames[] = {
26595 (char *) "self",(char *) "maxSize", NULL
26596 };
26597
26598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26600 if (SWIG_arg_fail(1)) SWIG_fail;
26601 {
26602 arg2 = &temp2;
26603 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26604 }
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 (arg1)->SetMaxSize((wxSize const &)*arg2);
26608
26609 wxPyEndAllowThreads(__tstate);
26610 if (PyErr_Occurred()) SWIG_fail;
26611 }
26612 Py_INCREF(Py_None); resultobj = Py_None;
26613 return resultobj;
26614 fail:
26615 return NULL;
26616 }
26617
26618
26619 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26620 PyObject *resultobj;
26621 wxWindow *arg1 = (wxWindow *) 0 ;
26622 int result;
26623 PyObject * obj0 = 0 ;
26624 char *kwnames[] = {
26625 (char *) "self", NULL
26626 };
26627
26628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26630 if (SWIG_arg_fail(1)) SWIG_fail;
26631 {
26632 PyThreadState* __tstate = wxPyBeginAllowThreads();
26633 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26634
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 {
26639 resultobj = SWIG_From_int((int)(result));
26640 }
26641 return resultobj;
26642 fail:
26643 return NULL;
26644 }
26645
26646
26647 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj;
26649 wxWindow *arg1 = (wxWindow *) 0 ;
26650 int result;
26651 PyObject * obj0 = 0 ;
26652 char *kwnames[] = {
26653 (char *) "self", NULL
26654 };
26655
26656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26658 if (SWIG_arg_fail(1)) SWIG_fail;
26659 {
26660 PyThreadState* __tstate = wxPyBeginAllowThreads();
26661 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26662
26663 wxPyEndAllowThreads(__tstate);
26664 if (PyErr_Occurred()) SWIG_fail;
26665 }
26666 {
26667 resultobj = SWIG_From_int((int)(result));
26668 }
26669 return resultobj;
26670 fail:
26671 return NULL;
26672 }
26673
26674
26675 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26676 PyObject *resultobj;
26677 wxWindow *arg1 = (wxWindow *) 0 ;
26678 int result;
26679 PyObject * obj0 = 0 ;
26680 char *kwnames[] = {
26681 (char *) "self", NULL
26682 };
26683
26684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26686 if (SWIG_arg_fail(1)) SWIG_fail;
26687 {
26688 PyThreadState* __tstate = wxPyBeginAllowThreads();
26689 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26690
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 {
26695 resultobj = SWIG_From_int((int)(result));
26696 }
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26704 PyObject *resultobj;
26705 wxWindow *arg1 = (wxWindow *) 0 ;
26706 int result;
26707 PyObject * obj0 = 0 ;
26708 char *kwnames[] = {
26709 (char *) "self", NULL
26710 };
26711
26712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26714 if (SWIG_arg_fail(1)) SWIG_fail;
26715 {
26716 PyThreadState* __tstate = wxPyBeginAllowThreads();
26717 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26718
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = SWIG_From_int((int)(result));
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj;
26733 wxWindow *arg1 = (wxWindow *) 0 ;
26734 wxSize *arg2 = 0 ;
26735 wxSize temp2 ;
26736 PyObject * obj0 = 0 ;
26737 PyObject * obj1 = 0 ;
26738 char *kwnames[] = {
26739 (char *) "self",(char *) "size", NULL
26740 };
26741
26742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26744 if (SWIG_arg_fail(1)) SWIG_fail;
26745 {
26746 arg2 = &temp2;
26747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26748 }
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26752
26753 wxPyEndAllowThreads(__tstate);
26754 if (PyErr_Occurred()) SWIG_fail;
26755 }
26756 Py_INCREF(Py_None); resultobj = Py_None;
26757 return resultobj;
26758 fail:
26759 return NULL;
26760 }
26761
26762
26763 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26764 PyObject *resultobj;
26765 wxWindow *arg1 = (wxWindow *) 0 ;
26766 int arg2 ;
26767 int arg3 ;
26768 PyObject * obj0 = 0 ;
26769 PyObject * obj1 = 0 ;
26770 PyObject * obj2 = 0 ;
26771 char *kwnames[] = {
26772 (char *) "self",(char *) "w",(char *) "h", NULL
26773 };
26774
26775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26777 if (SWIG_arg_fail(1)) SWIG_fail;
26778 {
26779 arg2 = (int)(SWIG_As_int(obj1));
26780 if (SWIG_arg_fail(2)) SWIG_fail;
26781 }
26782 {
26783 arg3 = (int)(SWIG_As_int(obj2));
26784 if (SWIG_arg_fail(3)) SWIG_fail;
26785 }
26786 {
26787 PyThreadState* __tstate = wxPyBeginAllowThreads();
26788 (arg1)->SetVirtualSize(arg2,arg3);
26789
26790 wxPyEndAllowThreads(__tstate);
26791 if (PyErr_Occurred()) SWIG_fail;
26792 }
26793 Py_INCREF(Py_None); resultobj = Py_None;
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj;
26802 wxWindow *arg1 = (wxWindow *) 0 ;
26803 wxSize result;
26804 PyObject * obj0 = 0 ;
26805 char *kwnames[] = {
26806 (char *) "self", NULL
26807 };
26808
26809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26811 if (SWIG_arg_fail(1)) SWIG_fail;
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 result = ((wxWindow const *)arg1)->GetVirtualSize();
26815
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 {
26820 wxSize * resultptr;
26821 resultptr = new wxSize((wxSize &)(result));
26822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26823 }
26824 return resultobj;
26825 fail:
26826 return NULL;
26827 }
26828
26829
26830 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26831 PyObject *resultobj;
26832 wxWindow *arg1 = (wxWindow *) 0 ;
26833 int *arg2 = (int *) 0 ;
26834 int *arg3 = (int *) 0 ;
26835 int temp2 ;
26836 int res2 = 0 ;
26837 int temp3 ;
26838 int res3 = 0 ;
26839 PyObject * obj0 = 0 ;
26840 char *kwnames[] = {
26841 (char *) "self", NULL
26842 };
26843
26844 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26845 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26848 if (SWIG_arg_fail(1)) SWIG_fail;
26849 {
26850 PyThreadState* __tstate = wxPyBeginAllowThreads();
26851 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26852
26853 wxPyEndAllowThreads(__tstate);
26854 if (PyErr_Occurred()) SWIG_fail;
26855 }
26856 Py_INCREF(Py_None); resultobj = Py_None;
26857 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26858 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26859 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26860 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26868 PyObject *resultobj;
26869 wxWindow *arg1 = (wxWindow *) 0 ;
26870 wxSize result;
26871 PyObject * obj0 = 0 ;
26872 char *kwnames[] = {
26873 (char *) "self", NULL
26874 };
26875
26876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26878 if (SWIG_arg_fail(1)) SWIG_fail;
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26882
26883 wxPyEndAllowThreads(__tstate);
26884 if (PyErr_Occurred()) SWIG_fail;
26885 }
26886 {
26887 wxSize * resultptr;
26888 resultptr = new wxSize((wxSize &)(result));
26889 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26890 }
26891 return resultobj;
26892 fail:
26893 return NULL;
26894 }
26895
26896
26897 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26898 PyObject *resultobj;
26899 wxWindow *arg1 = (wxWindow *) 0 ;
26900 bool arg2 = (bool) true ;
26901 bool result;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char *kwnames[] = {
26905 (char *) "self",(char *) "show", NULL
26906 };
26907
26908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26910 if (SWIG_arg_fail(1)) SWIG_fail;
26911 if (obj1) {
26912 {
26913 arg2 = (bool)(SWIG_As_bool(obj1));
26914 if (SWIG_arg_fail(2)) SWIG_fail;
26915 }
26916 }
26917 {
26918 PyThreadState* __tstate = wxPyBeginAllowThreads();
26919 result = (bool)(arg1)->Show(arg2);
26920
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 {
26925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26926 }
26927 return resultobj;
26928 fail:
26929 return NULL;
26930 }
26931
26932
26933 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26934 PyObject *resultobj;
26935 wxWindow *arg1 = (wxWindow *) 0 ;
26936 bool result;
26937 PyObject * obj0 = 0 ;
26938 char *kwnames[] = {
26939 (char *) "self", NULL
26940 };
26941
26942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26944 if (SWIG_arg_fail(1)) SWIG_fail;
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 result = (bool)(arg1)->Hide();
26948
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 {
26953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26954 }
26955 return resultobj;
26956 fail:
26957 return NULL;
26958 }
26959
26960
26961 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26962 PyObject *resultobj;
26963 wxWindow *arg1 = (wxWindow *) 0 ;
26964 bool arg2 = (bool) true ;
26965 bool result;
26966 PyObject * obj0 = 0 ;
26967 PyObject * obj1 = 0 ;
26968 char *kwnames[] = {
26969 (char *) "self",(char *) "enable", NULL
26970 };
26971
26972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26974 if (SWIG_arg_fail(1)) SWIG_fail;
26975 if (obj1) {
26976 {
26977 arg2 = (bool)(SWIG_As_bool(obj1));
26978 if (SWIG_arg_fail(2)) SWIG_fail;
26979 }
26980 }
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (bool)(arg1)->Enable(arg2);
26984
26985 wxPyEndAllowThreads(__tstate);
26986 if (PyErr_Occurred()) SWIG_fail;
26987 }
26988 {
26989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26990 }
26991 return resultobj;
26992 fail:
26993 return NULL;
26994 }
26995
26996
26997 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26998 PyObject *resultobj;
26999 wxWindow *arg1 = (wxWindow *) 0 ;
27000 bool result;
27001 PyObject * obj0 = 0 ;
27002 char *kwnames[] = {
27003 (char *) "self", NULL
27004 };
27005
27006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27008 if (SWIG_arg_fail(1)) SWIG_fail;
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 result = (bool)(arg1)->Disable();
27012
27013 wxPyEndAllowThreads(__tstate);
27014 if (PyErr_Occurred()) SWIG_fail;
27015 }
27016 {
27017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27018 }
27019 return resultobj;
27020 fail:
27021 return NULL;
27022 }
27023
27024
27025 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27026 PyObject *resultobj;
27027 wxWindow *arg1 = (wxWindow *) 0 ;
27028 bool result;
27029 PyObject * obj0 = 0 ;
27030 char *kwnames[] = {
27031 (char *) "self", NULL
27032 };
27033
27034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27036 if (SWIG_arg_fail(1)) SWIG_fail;
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 result = (bool)((wxWindow const *)arg1)->IsShown();
27040
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 {
27045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27046 }
27047 return resultobj;
27048 fail:
27049 return NULL;
27050 }
27051
27052
27053 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj;
27055 wxWindow *arg1 = (wxWindow *) 0 ;
27056 bool result;
27057 PyObject * obj0 = 0 ;
27058 char *kwnames[] = {
27059 (char *) "self", NULL
27060 };
27061
27062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(1)) SWIG_fail;
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27068
27069 wxPyEndAllowThreads(__tstate);
27070 if (PyErr_Occurred()) SWIG_fail;
27071 }
27072 {
27073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27074 }
27075 return resultobj;
27076 fail:
27077 return NULL;
27078 }
27079
27080
27081 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27082 PyObject *resultobj;
27083 wxWindow *arg1 = (wxWindow *) 0 ;
27084 long arg2 ;
27085 PyObject * obj0 = 0 ;
27086 PyObject * obj1 = 0 ;
27087 char *kwnames[] = {
27088 (char *) "self",(char *) "style", NULL
27089 };
27090
27091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27093 if (SWIG_arg_fail(1)) SWIG_fail;
27094 {
27095 arg2 = (long)(SWIG_As_long(obj1));
27096 if (SWIG_arg_fail(2)) SWIG_fail;
27097 }
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 (arg1)->SetWindowStyleFlag(arg2);
27101
27102 wxPyEndAllowThreads(__tstate);
27103 if (PyErr_Occurred()) SWIG_fail;
27104 }
27105 Py_INCREF(Py_None); resultobj = Py_None;
27106 return resultobj;
27107 fail:
27108 return NULL;
27109 }
27110
27111
27112 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj;
27114 wxWindow *arg1 = (wxWindow *) 0 ;
27115 long result;
27116 PyObject * obj0 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self", NULL
27119 };
27120
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",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 = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = SWIG_From_long((long)(result));
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxWindow *arg1 = (wxWindow *) 0 ;
27143 int arg2 ;
27144 bool result;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char *kwnames[] = {
27148 (char *) "self",(char *) "flag", NULL
27149 };
27150
27151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27153 if (SWIG_arg_fail(1)) SWIG_fail;
27154 {
27155 arg2 = (int)(SWIG_As_int(obj1));
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 }
27158 {
27159 PyThreadState* __tstate = wxPyBeginAllowThreads();
27160 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27161
27162 wxPyEndAllowThreads(__tstate);
27163 if (PyErr_Occurred()) SWIG_fail;
27164 }
27165 {
27166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27167 }
27168 return resultobj;
27169 fail:
27170 return NULL;
27171 }
27172
27173
27174 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27175 PyObject *resultobj;
27176 wxWindow *arg1 = (wxWindow *) 0 ;
27177 bool result;
27178 PyObject * obj0 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 result = (bool)((wxWindow const *)arg1)->IsRetained();
27189
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 {
27194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27195 }
27196 return resultobj;
27197 fail:
27198 return NULL;
27199 }
27200
27201
27202 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27203 PyObject *resultobj;
27204 wxWindow *arg1 = (wxWindow *) 0 ;
27205 long arg2 ;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self",(char *) "exStyle", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27214 if (SWIG_arg_fail(1)) SWIG_fail;
27215 {
27216 arg2 = (long)(SWIG_As_long(obj1));
27217 if (SWIG_arg_fail(2)) SWIG_fail;
27218 }
27219 {
27220 PyThreadState* __tstate = wxPyBeginAllowThreads();
27221 (arg1)->SetExtraStyle(arg2);
27222
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 Py_INCREF(Py_None); resultobj = Py_None;
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27234 PyObject *resultobj;
27235 wxWindow *arg1 = (wxWindow *) 0 ;
27236 long result;
27237 PyObject * obj0 = 0 ;
27238 char *kwnames[] = {
27239 (char *) "self", NULL
27240 };
27241
27242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27244 if (SWIG_arg_fail(1)) SWIG_fail;
27245 {
27246 PyThreadState* __tstate = wxPyBeginAllowThreads();
27247 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27248
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 {
27253 resultobj = SWIG_From_long((long)(result));
27254 }
27255 return resultobj;
27256 fail:
27257 return NULL;
27258 }
27259
27260
27261 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27262 PyObject *resultobj;
27263 wxWindow *arg1 = (wxWindow *) 0 ;
27264 bool arg2 = (bool) true ;
27265 PyObject * obj0 = 0 ;
27266 PyObject * obj1 = 0 ;
27267 char *kwnames[] = {
27268 (char *) "self",(char *) "modal", NULL
27269 };
27270
27271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 if (obj1) {
27275 {
27276 arg2 = (bool)(SWIG_As_bool(obj1));
27277 if (SWIG_arg_fail(2)) SWIG_fail;
27278 }
27279 }
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 (arg1)->MakeModal(arg2);
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 Py_INCREF(Py_None); resultobj = Py_None;
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj;
27296 wxWindow *arg1 = (wxWindow *) 0 ;
27297 bool arg2 ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "self",(char *) "enableTheme", NULL
27302 };
27303
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(1)) SWIG_fail;
27307 {
27308 arg2 = (bool)(SWIG_As_bool(obj1));
27309 if (SWIG_arg_fail(2)) SWIG_fail;
27310 }
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 (arg1)->SetThemeEnabled(arg2);
27314
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 Py_INCREF(Py_None); resultobj = Py_None;
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27326 PyObject *resultobj;
27327 wxWindow *arg1 = (wxWindow *) 0 ;
27328 bool result;
27329 PyObject * obj0 = 0 ;
27330 char *kwnames[] = {
27331 (char *) "self", NULL
27332 };
27333
27334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27336 if (SWIG_arg_fail(1)) SWIG_fail;
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27340
27341 wxPyEndAllowThreads(__tstate);
27342 if (PyErr_Occurred()) SWIG_fail;
27343 }
27344 {
27345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27346 }
27347 return resultobj;
27348 fail:
27349 return NULL;
27350 }
27351
27352
27353 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27354 PyObject *resultobj;
27355 wxWindow *arg1 = (wxWindow *) 0 ;
27356 PyObject * obj0 = 0 ;
27357 char *kwnames[] = {
27358 (char *) "self", NULL
27359 };
27360
27361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27363 if (SWIG_arg_fail(1)) SWIG_fail;
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 (arg1)->SetFocus();
27367
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 Py_INCREF(Py_None); resultobj = Py_None;
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27379 PyObject *resultobj;
27380 wxWindow *arg1 = (wxWindow *) 0 ;
27381 PyObject * obj0 = 0 ;
27382 char *kwnames[] = {
27383 (char *) "self", NULL
27384 };
27385
27386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27388 if (SWIG_arg_fail(1)) SWIG_fail;
27389 {
27390 PyThreadState* __tstate = wxPyBeginAllowThreads();
27391 (arg1)->SetFocusFromKbd();
27392
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 Py_INCREF(Py_None); resultobj = Py_None;
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27404 PyObject *resultobj;
27405 wxWindow *result;
27406 char *kwnames[] = {
27407 NULL
27408 };
27409
27410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27411 {
27412 if (!wxPyCheckForApp()) SWIG_fail;
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 result = (wxWindow *)wxWindow::FindFocus();
27415
27416 wxPyEndAllowThreads(__tstate);
27417 if (PyErr_Occurred()) SWIG_fail;
27418 }
27419 {
27420 resultobj = wxPyMake_wxObject(result, 0);
27421 }
27422 return resultobj;
27423 fail:
27424 return NULL;
27425 }
27426
27427
27428 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj;
27430 wxWindow *arg1 = (wxWindow *) 0 ;
27431 bool result;
27432 PyObject * obj0 = 0 ;
27433 char *kwnames[] = {
27434 (char *) "self", NULL
27435 };
27436
27437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) 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 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27443
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 {
27448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27449 }
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27457 PyObject *resultobj;
27458 wxWindow *arg1 = (wxWindow *) 0 ;
27459 bool result;
27460 PyObject * obj0 = 0 ;
27461 char *kwnames[] = {
27462 (char *) "self", NULL
27463 };
27464
27465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27467 if (SWIG_arg_fail(1)) SWIG_fail;
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27471
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 {
27476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27477 }
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27485 PyObject *resultobj;
27486 wxWindow *arg1 = (wxWindow *) 0 ;
27487 wxWindow *result;
27488 PyObject * obj0 = 0 ;
27489 char *kwnames[] = {
27490 (char *) "self", NULL
27491 };
27492
27493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27495 if (SWIG_arg_fail(1)) SWIG_fail;
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27499
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 {
27504 resultobj = wxPyMake_wxObject(result, 0);
27505 }
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj;
27514 wxWindow *arg1 = (wxWindow *) 0 ;
27515 wxWindow *arg2 = (wxWindow *) 0 ;
27516 wxWindow *result;
27517 PyObject * obj0 = 0 ;
27518 PyObject * obj1 = 0 ;
27519 char *kwnames[] = {
27520 (char *) "self",(char *) "child", NULL
27521 };
27522
27523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27525 if (SWIG_arg_fail(1)) SWIG_fail;
27526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27527 if (SWIG_arg_fail(2)) SWIG_fail;
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27531
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 {
27536 resultobj = wxPyMake_wxObject(result, 0);
27537 }
27538 return resultobj;
27539 fail:
27540 return NULL;
27541 }
27542
27543
27544 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27545 PyObject *resultobj;
27546 wxWindow *arg1 = (wxWindow *) 0 ;
27547 wxWindow *arg2 = (wxWindow *) 0 ;
27548 PyObject * obj0 = 0 ;
27549 PyObject * obj1 = 0 ;
27550 char *kwnames[] = {
27551 (char *) "self",(char *) "win", NULL
27552 };
27553
27554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27556 if (SWIG_arg_fail(1)) SWIG_fail;
27557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27558 if (SWIG_arg_fail(2)) SWIG_fail;
27559 {
27560 PyThreadState* __tstate = wxPyBeginAllowThreads();
27561 (arg1)->SetTmpDefaultItem(arg2);
27562
27563 wxPyEndAllowThreads(__tstate);
27564 if (PyErr_Occurred()) SWIG_fail;
27565 }
27566 Py_INCREF(Py_None); resultobj = Py_None;
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27574 PyObject *resultobj;
27575 wxWindow *arg1 = (wxWindow *) 0 ;
27576 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27577 bool result;
27578 PyObject * obj0 = 0 ;
27579 PyObject * obj1 = 0 ;
27580 char *kwnames[] = {
27581 (char *) "self",(char *) "flags", NULL
27582 };
27583
27584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27586 if (SWIG_arg_fail(1)) SWIG_fail;
27587 if (obj1) {
27588 {
27589 arg2 = (int)(SWIG_As_int(obj1));
27590 if (SWIG_arg_fail(2)) SWIG_fail;
27591 }
27592 }
27593 {
27594 PyThreadState* __tstate = wxPyBeginAllowThreads();
27595 result = (bool)(arg1)->Navigate(arg2);
27596
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 {
27601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27602 }
27603 return resultobj;
27604 fail:
27605 return NULL;
27606 }
27607
27608
27609 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27610 PyObject *resultobj;
27611 wxWindow *arg1 = (wxWindow *) 0 ;
27612 wxWindow *arg2 = (wxWindow *) 0 ;
27613 PyObject * obj0 = 0 ;
27614 PyObject * obj1 = 0 ;
27615 char *kwnames[] = {
27616 (char *) "self",(char *) "win", NULL
27617 };
27618
27619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27621 if (SWIG_arg_fail(1)) SWIG_fail;
27622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27623 if (SWIG_arg_fail(2)) SWIG_fail;
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 (arg1)->MoveAfterInTabOrder(arg2);
27627
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 Py_INCREF(Py_None); resultobj = Py_None;
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxWindow *arg1 = (wxWindow *) 0 ;
27641 wxWindow *arg2 = (wxWindow *) 0 ;
27642 PyObject * obj0 = 0 ;
27643 PyObject * obj1 = 0 ;
27644 char *kwnames[] = {
27645 (char *) "self",(char *) "win", NULL
27646 };
27647
27648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27652 if (SWIG_arg_fail(2)) SWIG_fail;
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 (arg1)->MoveBeforeInTabOrder(arg2);
27656
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 Py_INCREF(Py_None); resultobj = Py_None;
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxWindow *arg1 = (wxWindow *) 0 ;
27670 PyObject *result;
27671 PyObject * obj0 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 {
27680 PyThreadState* __tstate = wxPyBeginAllowThreads();
27681 result = (PyObject *)wxWindow_GetChildren(arg1);
27682
27683 wxPyEndAllowThreads(__tstate);
27684 if (PyErr_Occurred()) SWIG_fail;
27685 }
27686 resultobj = result;
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj;
27695 wxWindow *arg1 = (wxWindow *) 0 ;
27696 wxWindow *result;
27697 PyObject * obj0 = 0 ;
27698 char *kwnames[] = {
27699 (char *) "self", NULL
27700 };
27701
27702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27704 if (SWIG_arg_fail(1)) SWIG_fail;
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27708
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 {
27713 resultobj = wxPyMake_wxObject(result, 0);
27714 }
27715 return resultobj;
27716 fail:
27717 return NULL;
27718 }
27719
27720
27721 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27722 PyObject *resultobj;
27723 wxWindow *arg1 = (wxWindow *) 0 ;
27724 wxWindow *result;
27725 PyObject * obj0 = 0 ;
27726 char *kwnames[] = {
27727 (char *) "self", NULL
27728 };
27729
27730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27732 if (SWIG_arg_fail(1)) SWIG_fail;
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27736
27737 wxPyEndAllowThreads(__tstate);
27738 if (PyErr_Occurred()) SWIG_fail;
27739 }
27740 {
27741 resultobj = wxPyMake_wxObject(result, 0);
27742 }
27743 return resultobj;
27744 fail:
27745 return NULL;
27746 }
27747
27748
27749 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27750 PyObject *resultobj;
27751 wxWindow *arg1 = (wxWindow *) 0 ;
27752 bool result;
27753 PyObject * obj0 = 0 ;
27754 char *kwnames[] = {
27755 (char *) "self", NULL
27756 };
27757
27758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27760 if (SWIG_arg_fail(1)) SWIG_fail;
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27764
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 {
27769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27770 }
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj;
27779 wxWindow *arg1 = (wxWindow *) 0 ;
27780 wxWindow *arg2 = (wxWindow *) 0 ;
27781 bool result;
27782 PyObject * obj0 = 0 ;
27783 PyObject * obj1 = 0 ;
27784 char *kwnames[] = {
27785 (char *) "self",(char *) "newParent", NULL
27786 };
27787
27788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27790 if (SWIG_arg_fail(1)) SWIG_fail;
27791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27792 if (SWIG_arg_fail(2)) SWIG_fail;
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = (bool)(arg1)->Reparent(arg2);
27796
27797 wxPyEndAllowThreads(__tstate);
27798 if (PyErr_Occurred()) SWIG_fail;
27799 }
27800 {
27801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27802 }
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27810 PyObject *resultobj;
27811 wxWindow *arg1 = (wxWindow *) 0 ;
27812 wxWindow *arg2 = (wxWindow *) 0 ;
27813 PyObject * obj0 = 0 ;
27814 PyObject * obj1 = 0 ;
27815 char *kwnames[] = {
27816 (char *) "self",(char *) "child", NULL
27817 };
27818
27819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27821 if (SWIG_arg_fail(1)) SWIG_fail;
27822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27823 if (SWIG_arg_fail(2)) SWIG_fail;
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 (arg1)->AddChild(arg2);
27827
27828 wxPyEndAllowThreads(__tstate);
27829 if (PyErr_Occurred()) SWIG_fail;
27830 }
27831 Py_INCREF(Py_None); resultobj = Py_None;
27832 return resultobj;
27833 fail:
27834 return NULL;
27835 }
27836
27837
27838 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27839 PyObject *resultobj;
27840 wxWindow *arg1 = (wxWindow *) 0 ;
27841 wxWindow *arg2 = (wxWindow *) 0 ;
27842 PyObject * obj0 = 0 ;
27843 PyObject * obj1 = 0 ;
27844 char *kwnames[] = {
27845 (char *) "self",(char *) "child", NULL
27846 };
27847
27848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27850 if (SWIG_arg_fail(1)) SWIG_fail;
27851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27852 if (SWIG_arg_fail(2)) SWIG_fail;
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 (arg1)->RemoveChild(arg2);
27856
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 Py_INCREF(Py_None); resultobj = Py_None;
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj;
27869 wxWindow *arg1 = (wxWindow *) 0 ;
27870 long arg2 ;
27871 wxWindow *result;
27872 PyObject * obj0 = 0 ;
27873 PyObject * obj1 = 0 ;
27874 char *kwnames[] = {
27875 (char *) "self",(char *) "winid", NULL
27876 };
27877
27878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27880 if (SWIG_arg_fail(1)) SWIG_fail;
27881 {
27882 arg2 = (long)(SWIG_As_long(obj1));
27883 if (SWIG_arg_fail(2)) SWIG_fail;
27884 }
27885 {
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 result = (wxWindow *)(arg1)->FindWindow(arg2);
27888
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 {
27893 resultobj = wxPyMake_wxObject(result, 0);
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27902 PyObject *resultobj;
27903 wxWindow *arg1 = (wxWindow *) 0 ;
27904 wxString *arg2 = 0 ;
27905 wxWindow *result;
27906 bool temp2 = false ;
27907 PyObject * obj0 = 0 ;
27908 PyObject * obj1 = 0 ;
27909 char *kwnames[] = {
27910 (char *) "self",(char *) "name", NULL
27911 };
27912
27913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27915 if (SWIG_arg_fail(1)) SWIG_fail;
27916 {
27917 arg2 = wxString_in_helper(obj1);
27918 if (arg2 == NULL) SWIG_fail;
27919 temp2 = true;
27920 }
27921 {
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27924
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 {
27929 resultobj = wxPyMake_wxObject(result, 0);
27930 }
27931 {
27932 if (temp2)
27933 delete arg2;
27934 }
27935 return resultobj;
27936 fail:
27937 {
27938 if (temp2)
27939 delete arg2;
27940 }
27941 return NULL;
27942 }
27943
27944
27945 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj;
27947 wxWindow *arg1 = (wxWindow *) 0 ;
27948 wxEvtHandler *result;
27949 PyObject * obj0 = 0 ;
27950 char *kwnames[] = {
27951 (char *) "self", NULL
27952 };
27953
27954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27956 if (SWIG_arg_fail(1)) SWIG_fail;
27957 {
27958 PyThreadState* __tstate = wxPyBeginAllowThreads();
27959 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27960
27961 wxPyEndAllowThreads(__tstate);
27962 if (PyErr_Occurred()) SWIG_fail;
27963 }
27964 {
27965 resultobj = wxPyMake_wxObject(result, 0);
27966 }
27967 return resultobj;
27968 fail:
27969 return NULL;
27970 }
27971
27972
27973 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27974 PyObject *resultobj;
27975 wxWindow *arg1 = (wxWindow *) 0 ;
27976 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char *kwnames[] = {
27980 (char *) "self",(char *) "handler", NULL
27981 };
27982
27983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27985 if (SWIG_arg_fail(1)) SWIG_fail;
27986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27987 if (SWIG_arg_fail(2)) SWIG_fail;
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 (arg1)->SetEventHandler(arg2);
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 Py_INCREF(Py_None); resultobj = Py_None;
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj;
28004 wxWindow *arg1 = (wxWindow *) 0 ;
28005 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char *kwnames[] = {
28009 (char *) "self",(char *) "handler", NULL
28010 };
28011
28012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28014 if (SWIG_arg_fail(1)) SWIG_fail;
28015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28016 if (SWIG_arg_fail(2)) SWIG_fail;
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 (arg1)->PushEventHandler(arg2);
28020
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 Py_INCREF(Py_None); resultobj = Py_None;
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj;
28033 wxWindow *arg1 = (wxWindow *) 0 ;
28034 bool arg2 = (bool) false ;
28035 wxEvtHandler *result;
28036 PyObject * obj0 = 0 ;
28037 PyObject * obj1 = 0 ;
28038 char *kwnames[] = {
28039 (char *) "self",(char *) "deleteHandler", NULL
28040 };
28041
28042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28044 if (SWIG_arg_fail(1)) SWIG_fail;
28045 if (obj1) {
28046 {
28047 arg2 = (bool)(SWIG_As_bool(obj1));
28048 if (SWIG_arg_fail(2)) SWIG_fail;
28049 }
28050 }
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28054
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 {
28059 resultobj = wxPyMake_wxObject(result, 0);
28060 }
28061 return resultobj;
28062 fail:
28063 return NULL;
28064 }
28065
28066
28067 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28068 PyObject *resultobj;
28069 wxWindow *arg1 = (wxWindow *) 0 ;
28070 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28071 bool result;
28072 PyObject * obj0 = 0 ;
28073 PyObject * obj1 = 0 ;
28074 char *kwnames[] = {
28075 (char *) "self",(char *) "handler", NULL
28076 };
28077
28078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28080 if (SWIG_arg_fail(1)) SWIG_fail;
28081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28082 if (SWIG_arg_fail(2)) SWIG_fail;
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 result = (bool)(arg1)->RemoveEventHandler(arg2);
28086
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 {
28091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28092 }
28093 return resultobj;
28094 fail:
28095 return NULL;
28096 }
28097
28098
28099 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28100 PyObject *resultobj;
28101 wxWindow *arg1 = (wxWindow *) 0 ;
28102 wxValidator *arg2 = 0 ;
28103 PyObject * obj0 = 0 ;
28104 PyObject * obj1 = 0 ;
28105 char *kwnames[] = {
28106 (char *) "self",(char *) "validator", NULL
28107 };
28108
28109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28111 if (SWIG_arg_fail(1)) SWIG_fail;
28112 {
28113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28114 if (SWIG_arg_fail(2)) SWIG_fail;
28115 if (arg2 == NULL) {
28116 SWIG_null_ref("wxValidator");
28117 }
28118 if (SWIG_arg_fail(2)) SWIG_fail;
28119 }
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 (arg1)->SetValidator((wxValidator const &)*arg2);
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 Py_INCREF(Py_None); resultobj = Py_None;
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj;
28136 wxWindow *arg1 = (wxWindow *) 0 ;
28137 wxValidator *result;
28138 PyObject * obj0 = 0 ;
28139 char *kwnames[] = {
28140 (char *) "self", NULL
28141 };
28142
28143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28145 if (SWIG_arg_fail(1)) SWIG_fail;
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 result = (wxValidator *)(arg1)->GetValidator();
28149
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 resultobj = wxPyMake_wxObject(result, 0);
28155 }
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28163 PyObject *resultobj;
28164 wxWindow *arg1 = (wxWindow *) 0 ;
28165 bool result;
28166 PyObject * obj0 = 0 ;
28167 char *kwnames[] = {
28168 (char *) "self", NULL
28169 };
28170
28171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28173 if (SWIG_arg_fail(1)) SWIG_fail;
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (bool)(arg1)->Validate();
28177
28178 wxPyEndAllowThreads(__tstate);
28179 if (PyErr_Occurred()) SWIG_fail;
28180 }
28181 {
28182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28183 }
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28191 PyObject *resultobj;
28192 wxWindow *arg1 = (wxWindow *) 0 ;
28193 bool result;
28194 PyObject * obj0 = 0 ;
28195 char *kwnames[] = {
28196 (char *) "self", NULL
28197 };
28198
28199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28201 if (SWIG_arg_fail(1)) SWIG_fail;
28202 {
28203 PyThreadState* __tstate = wxPyBeginAllowThreads();
28204 result = (bool)(arg1)->TransferDataToWindow();
28205
28206 wxPyEndAllowThreads(__tstate);
28207 if (PyErr_Occurred()) SWIG_fail;
28208 }
28209 {
28210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28211 }
28212 return resultobj;
28213 fail:
28214 return NULL;
28215 }
28216
28217
28218 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28219 PyObject *resultobj;
28220 wxWindow *arg1 = (wxWindow *) 0 ;
28221 bool result;
28222 PyObject * obj0 = 0 ;
28223 char *kwnames[] = {
28224 (char *) "self", NULL
28225 };
28226
28227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28229 if (SWIG_arg_fail(1)) SWIG_fail;
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 result = (bool)(arg1)->TransferDataFromWindow();
28233
28234 wxPyEndAllowThreads(__tstate);
28235 if (PyErr_Occurred()) SWIG_fail;
28236 }
28237 {
28238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28239 }
28240 return resultobj;
28241 fail:
28242 return NULL;
28243 }
28244
28245
28246 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28247 PyObject *resultobj;
28248 wxWindow *arg1 = (wxWindow *) 0 ;
28249 PyObject * obj0 = 0 ;
28250 char *kwnames[] = {
28251 (char *) "self", NULL
28252 };
28253
28254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28256 if (SWIG_arg_fail(1)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 (arg1)->InitDialog();
28260
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 Py_INCREF(Py_None); resultobj = Py_None;
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj;
28273 wxWindow *arg1 = (wxWindow *) 0 ;
28274 wxAcceleratorTable *arg2 = 0 ;
28275 PyObject * obj0 = 0 ;
28276 PyObject * obj1 = 0 ;
28277 char *kwnames[] = {
28278 (char *) "self",(char *) "accel", NULL
28279 };
28280
28281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28283 if (SWIG_arg_fail(1)) SWIG_fail;
28284 {
28285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28286 if (SWIG_arg_fail(2)) SWIG_fail;
28287 if (arg2 == NULL) {
28288 SWIG_null_ref("wxAcceleratorTable");
28289 }
28290 if (SWIG_arg_fail(2)) SWIG_fail;
28291 }
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28295
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 Py_INCREF(Py_None); resultobj = Py_None;
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28307 PyObject *resultobj;
28308 wxWindow *arg1 = (wxWindow *) 0 ;
28309 wxAcceleratorTable *result;
28310 PyObject * obj0 = 0 ;
28311 char *kwnames[] = {
28312 (char *) "self", NULL
28313 };
28314
28315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28317 if (SWIG_arg_fail(1)) SWIG_fail;
28318 {
28319 PyThreadState* __tstate = wxPyBeginAllowThreads();
28320 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28321
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj;
28334 wxWindow *arg1 = (wxWindow *) 0 ;
28335 int arg2 ;
28336 int arg3 ;
28337 int arg4 ;
28338 bool result;
28339 PyObject * obj0 = 0 ;
28340 PyObject * obj1 = 0 ;
28341 PyObject * obj2 = 0 ;
28342 PyObject * obj3 = 0 ;
28343 char *kwnames[] = {
28344 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28345 };
28346
28347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28349 if (SWIG_arg_fail(1)) SWIG_fail;
28350 {
28351 arg2 = (int)(SWIG_As_int(obj1));
28352 if (SWIG_arg_fail(2)) SWIG_fail;
28353 }
28354 {
28355 arg3 = (int)(SWIG_As_int(obj2));
28356 if (SWIG_arg_fail(3)) SWIG_fail;
28357 }
28358 {
28359 arg4 = (int)(SWIG_As_int(obj3));
28360 if (SWIG_arg_fail(4)) SWIG_fail;
28361 }
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 {
28370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28371 }
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxWindow *arg1 = (wxWindow *) 0 ;
28381 int arg2 ;
28382 bool result;
28383 PyObject * obj0 = 0 ;
28384 PyObject * obj1 = 0 ;
28385 char *kwnames[] = {
28386 (char *) "self",(char *) "hotkeyId", NULL
28387 };
28388
28389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28391 if (SWIG_arg_fail(1)) SWIG_fail;
28392 {
28393 arg2 = (int)(SWIG_As_int(obj1));
28394 if (SWIG_arg_fail(2)) SWIG_fail;
28395 }
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28399
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 {
28404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28405 }
28406 return resultobj;
28407 fail:
28408 return NULL;
28409 }
28410
28411
28412 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28413 PyObject *resultobj;
28414 wxWindow *arg1 = (wxWindow *) 0 ;
28415 wxPoint *arg2 = 0 ;
28416 wxPoint result;
28417 wxPoint temp2 ;
28418 PyObject * obj0 = 0 ;
28419 PyObject * obj1 = 0 ;
28420 char *kwnames[] = {
28421 (char *) "self",(char *) "pt", NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 {
28428 arg2 = &temp2;
28429 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28430 }
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28434
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 {
28439 wxPoint * resultptr;
28440 resultptr = new wxPoint((wxPoint &)(result));
28441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28442 }
28443 return resultobj;
28444 fail:
28445 return NULL;
28446 }
28447
28448
28449 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28450 PyObject *resultobj;
28451 wxWindow *arg1 = (wxWindow *) 0 ;
28452 wxSize *arg2 = 0 ;
28453 wxSize result;
28454 wxSize temp2 ;
28455 PyObject * obj0 = 0 ;
28456 PyObject * obj1 = 0 ;
28457 char *kwnames[] = {
28458 (char *) "self",(char *) "sz", NULL
28459 };
28460
28461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28463 if (SWIG_arg_fail(1)) SWIG_fail;
28464 {
28465 arg2 = &temp2;
28466 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28467 }
28468 {
28469 PyThreadState* __tstate = wxPyBeginAllowThreads();
28470 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28471
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 {
28476 wxSize * resultptr;
28477 resultptr = new wxSize((wxSize &)(result));
28478 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj;
28488 wxWindow *arg1 = (wxWindow *) 0 ;
28489 wxPoint *arg2 = 0 ;
28490 wxPoint result;
28491 wxPoint temp2 ;
28492 PyObject * obj0 = 0 ;
28493 PyObject * obj1 = 0 ;
28494 char *kwnames[] = {
28495 (char *) "self",(char *) "pt", NULL
28496 };
28497
28498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28500 if (SWIG_arg_fail(1)) SWIG_fail;
28501 {
28502 arg2 = &temp2;
28503 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28504 }
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28508
28509 wxPyEndAllowThreads(__tstate);
28510 if (PyErr_Occurred()) SWIG_fail;
28511 }
28512 {
28513 wxPoint * resultptr;
28514 resultptr = new wxPoint((wxPoint &)(result));
28515 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28516 }
28517 return resultobj;
28518 fail:
28519 return NULL;
28520 }
28521
28522
28523 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28524 PyObject *resultobj;
28525 wxWindow *arg1 = (wxWindow *) 0 ;
28526 wxSize *arg2 = 0 ;
28527 wxSize result;
28528 wxSize temp2 ;
28529 PyObject * obj0 = 0 ;
28530 PyObject * obj1 = 0 ;
28531 char *kwnames[] = {
28532 (char *) "self",(char *) "sz", NULL
28533 };
28534
28535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28537 if (SWIG_arg_fail(1)) SWIG_fail;
28538 {
28539 arg2 = &temp2;
28540 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28541 }
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28545
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 wxSize * resultptr;
28551 resultptr = new wxSize((wxSize &)(result));
28552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28553 }
28554 return resultobj;
28555 fail:
28556 return NULL;
28557 }
28558
28559
28560 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28561 PyObject *resultobj;
28562 wxWindow *arg1 = (wxWindow *) 0 ;
28563 wxPoint *arg2 = 0 ;
28564 wxPoint result;
28565 wxPoint temp2 ;
28566 PyObject * obj0 = 0 ;
28567 PyObject * obj1 = 0 ;
28568 char *kwnames[] = {
28569 (char *) "self",(char *) "pt", NULL
28570 };
28571
28572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(1)) SWIG_fail;
28575 {
28576 arg2 = &temp2;
28577 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28578 }
28579 {
28580 PyThreadState* __tstate = wxPyBeginAllowThreads();
28581 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28582
28583 wxPyEndAllowThreads(__tstate);
28584 if (PyErr_Occurred()) SWIG_fail;
28585 }
28586 {
28587 wxPoint * resultptr;
28588 resultptr = new wxPoint((wxPoint &)(result));
28589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28590 }
28591 return resultobj;
28592 fail:
28593 return NULL;
28594 }
28595
28596
28597 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28598 PyObject *resultobj;
28599 wxWindow *arg1 = (wxWindow *) 0 ;
28600 wxSize *arg2 = 0 ;
28601 wxSize result;
28602 wxSize temp2 ;
28603 PyObject * obj0 = 0 ;
28604 PyObject * obj1 = 0 ;
28605 char *kwnames[] = {
28606 (char *) "self",(char *) "sz", NULL
28607 };
28608
28609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28611 if (SWIG_arg_fail(1)) SWIG_fail;
28612 {
28613 arg2 = &temp2;
28614 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28615 }
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28619
28620 wxPyEndAllowThreads(__tstate);
28621 if (PyErr_Occurred()) SWIG_fail;
28622 }
28623 {
28624 wxSize * resultptr;
28625 resultptr = new wxSize((wxSize &)(result));
28626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28627 }
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj;
28636 wxWindow *arg1 = (wxWindow *) 0 ;
28637 int arg2 ;
28638 int arg3 ;
28639 PyObject * obj0 = 0 ;
28640 PyObject * obj1 = 0 ;
28641 PyObject * obj2 = 0 ;
28642 char *kwnames[] = {
28643 (char *) "self",(char *) "x",(char *) "y", NULL
28644 };
28645
28646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28648 if (SWIG_arg_fail(1)) SWIG_fail;
28649 {
28650 arg2 = (int)(SWIG_As_int(obj1));
28651 if (SWIG_arg_fail(2)) SWIG_fail;
28652 }
28653 {
28654 arg3 = (int)(SWIG_As_int(obj2));
28655 if (SWIG_arg_fail(3)) SWIG_fail;
28656 }
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 (arg1)->WarpPointer(arg2,arg3);
28660
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 Py_INCREF(Py_None); resultobj = Py_None;
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj;
28673 wxWindow *arg1 = (wxWindow *) 0 ;
28674 PyObject * obj0 = 0 ;
28675 char *kwnames[] = {
28676 (char *) "self", NULL
28677 };
28678
28679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28681 if (SWIG_arg_fail(1)) SWIG_fail;
28682 {
28683 PyThreadState* __tstate = wxPyBeginAllowThreads();
28684 (arg1)->CaptureMouse();
28685
28686 wxPyEndAllowThreads(__tstate);
28687 if (PyErr_Occurred()) SWIG_fail;
28688 }
28689 Py_INCREF(Py_None); resultobj = Py_None;
28690 return resultobj;
28691 fail:
28692 return NULL;
28693 }
28694
28695
28696 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28697 PyObject *resultobj;
28698 wxWindow *arg1 = (wxWindow *) 0 ;
28699 PyObject * obj0 = 0 ;
28700 char *kwnames[] = {
28701 (char *) "self", NULL
28702 };
28703
28704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28706 if (SWIG_arg_fail(1)) SWIG_fail;
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 (arg1)->ReleaseMouse();
28710
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 Py_INCREF(Py_None); resultobj = Py_None;
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28722 PyObject *resultobj;
28723 wxWindow *result;
28724 char *kwnames[] = {
28725 NULL
28726 };
28727
28728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28729 {
28730 if (!wxPyCheckForApp()) SWIG_fail;
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 result = (wxWindow *)wxWindow::GetCapture();
28733
28734 wxPyEndAllowThreads(__tstate);
28735 if (PyErr_Occurred()) SWIG_fail;
28736 }
28737 {
28738 resultobj = wxPyMake_wxObject(result, 0);
28739 }
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28747 PyObject *resultobj;
28748 wxWindow *arg1 = (wxWindow *) 0 ;
28749 bool result;
28750 PyObject * obj0 = 0 ;
28751 char *kwnames[] = {
28752 (char *) "self", NULL
28753 };
28754
28755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28757 if (SWIG_arg_fail(1)) SWIG_fail;
28758 {
28759 PyThreadState* __tstate = wxPyBeginAllowThreads();
28760 result = (bool)((wxWindow const *)arg1)->HasCapture();
28761
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 {
28766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28767 }
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj;
28776 wxWindow *arg1 = (wxWindow *) 0 ;
28777 bool arg2 = (bool) true ;
28778 wxRect *arg3 = (wxRect *) NULL ;
28779 PyObject * obj0 = 0 ;
28780 PyObject * obj1 = 0 ;
28781 PyObject * obj2 = 0 ;
28782 char *kwnames[] = {
28783 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28784 };
28785
28786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28788 if (SWIG_arg_fail(1)) SWIG_fail;
28789 if (obj1) {
28790 {
28791 arg2 = (bool)(SWIG_As_bool(obj1));
28792 if (SWIG_arg_fail(2)) SWIG_fail;
28793 }
28794 }
28795 if (obj2) {
28796 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(3)) SWIG_fail;
28798 }
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28802
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 Py_INCREF(Py_None); resultobj = Py_None;
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj;
28815 wxWindow *arg1 = (wxWindow *) 0 ;
28816 wxRect *arg2 = 0 ;
28817 bool arg3 = (bool) true ;
28818 wxRect temp2 ;
28819 PyObject * obj0 = 0 ;
28820 PyObject * obj1 = 0 ;
28821 PyObject * obj2 = 0 ;
28822 char *kwnames[] = {
28823 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28824 };
28825
28826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28828 if (SWIG_arg_fail(1)) SWIG_fail;
28829 {
28830 arg2 = &temp2;
28831 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28832 }
28833 if (obj2) {
28834 {
28835 arg3 = (bool)(SWIG_As_bool(obj2));
28836 if (SWIG_arg_fail(3)) SWIG_fail;
28837 }
28838 }
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28842
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 Py_INCREF(Py_None); resultobj = Py_None;
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj;
28855 wxWindow *arg1 = (wxWindow *) 0 ;
28856 PyObject * obj0 = 0 ;
28857 char *kwnames[] = {
28858 (char *) "self", NULL
28859 };
28860
28861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28863 if (SWIG_arg_fail(1)) SWIG_fail;
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 (arg1)->Update();
28867
28868 wxPyEndAllowThreads(__tstate);
28869 if (PyErr_Occurred()) SWIG_fail;
28870 }
28871 Py_INCREF(Py_None); resultobj = Py_None;
28872 return resultobj;
28873 fail:
28874 return NULL;
28875 }
28876
28877
28878 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28879 PyObject *resultobj;
28880 wxWindow *arg1 = (wxWindow *) 0 ;
28881 PyObject * obj0 = 0 ;
28882 char *kwnames[] = {
28883 (char *) "self", NULL
28884 };
28885
28886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28888 if (SWIG_arg_fail(1)) SWIG_fail;
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 (arg1)->ClearBackground();
28892
28893 wxPyEndAllowThreads(__tstate);
28894 if (PyErr_Occurred()) SWIG_fail;
28895 }
28896 Py_INCREF(Py_None); resultobj = Py_None;
28897 return resultobj;
28898 fail:
28899 return NULL;
28900 }
28901
28902
28903 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28904 PyObject *resultobj;
28905 wxWindow *arg1 = (wxWindow *) 0 ;
28906 PyObject * obj0 = 0 ;
28907 char *kwnames[] = {
28908 (char *) "self", NULL
28909 };
28910
28911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28913 if (SWIG_arg_fail(1)) SWIG_fail;
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 (arg1)->Freeze();
28917
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 Py_INCREF(Py_None); resultobj = Py_None;
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28929 PyObject *resultobj;
28930 wxWindow *arg1 = (wxWindow *) 0 ;
28931 PyObject * obj0 = 0 ;
28932 char *kwnames[] = {
28933 (char *) "self", NULL
28934 };
28935
28936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28938 if (SWIG_arg_fail(1)) SWIG_fail;
28939 {
28940 PyThreadState* __tstate = wxPyBeginAllowThreads();
28941 (arg1)->Thaw();
28942
28943 wxPyEndAllowThreads(__tstate);
28944 if (PyErr_Occurred()) SWIG_fail;
28945 }
28946 Py_INCREF(Py_None); resultobj = Py_None;
28947 return resultobj;
28948 fail:
28949 return NULL;
28950 }
28951
28952
28953 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28954 PyObject *resultobj;
28955 wxWindow *arg1 = (wxWindow *) 0 ;
28956 wxDC *arg2 = 0 ;
28957 PyObject * obj0 = 0 ;
28958 PyObject * obj1 = 0 ;
28959 char *kwnames[] = {
28960 (char *) "self",(char *) "dc", NULL
28961 };
28962
28963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28968 if (SWIG_arg_fail(2)) SWIG_fail;
28969 if (arg2 == NULL) {
28970 SWIG_null_ref("wxDC");
28971 }
28972 if (SWIG_arg_fail(2)) SWIG_fail;
28973 }
28974 {
28975 PyThreadState* __tstate = wxPyBeginAllowThreads();
28976 (arg1)->PrepareDC(*arg2);
28977
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 Py_INCREF(Py_None); resultobj = Py_None;
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj;
28990 wxWindow *arg1 = (wxWindow *) 0 ;
28991 wxRegion *result;
28992 PyObject * obj0 = 0 ;
28993 char *kwnames[] = {
28994 (char *) "self", NULL
28995 };
28996
28997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28999 if (SWIG_arg_fail(1)) SWIG_fail;
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 {
29003 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29004 result = (wxRegion *) &_result_ref;
29005 }
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29018 PyObject *resultobj;
29019 wxWindow *arg1 = (wxWindow *) 0 ;
29020 wxRect result;
29021 PyObject * obj0 = 0 ;
29022 char *kwnames[] = {
29023 (char *) "self", NULL
29024 };
29025
29026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29028 if (SWIG_arg_fail(1)) SWIG_fail;
29029 {
29030 PyThreadState* __tstate = wxPyBeginAllowThreads();
29031 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29032
29033 wxPyEndAllowThreads(__tstate);
29034 if (PyErr_Occurred()) SWIG_fail;
29035 }
29036 {
29037 wxRect * resultptr;
29038 resultptr = new wxRect((wxRect &)(result));
29039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29040 }
29041 return resultobj;
29042 fail:
29043 return NULL;
29044 }
29045
29046
29047 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29048 PyObject *resultobj;
29049 wxWindow *arg1 = (wxWindow *) 0 ;
29050 int arg2 ;
29051 int arg3 ;
29052 int arg4 = (int) 1 ;
29053 int arg5 = (int) 1 ;
29054 bool result;
29055 PyObject * obj0 = 0 ;
29056 PyObject * obj1 = 0 ;
29057 PyObject * obj2 = 0 ;
29058 PyObject * obj3 = 0 ;
29059 PyObject * obj4 = 0 ;
29060 char *kwnames[] = {
29061 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29062 };
29063
29064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29066 if (SWIG_arg_fail(1)) SWIG_fail;
29067 {
29068 arg2 = (int)(SWIG_As_int(obj1));
29069 if (SWIG_arg_fail(2)) SWIG_fail;
29070 }
29071 {
29072 arg3 = (int)(SWIG_As_int(obj2));
29073 if (SWIG_arg_fail(3)) SWIG_fail;
29074 }
29075 if (obj3) {
29076 {
29077 arg4 = (int)(SWIG_As_int(obj3));
29078 if (SWIG_arg_fail(4)) SWIG_fail;
29079 }
29080 }
29081 if (obj4) {
29082 {
29083 arg5 = (int)(SWIG_As_int(obj4));
29084 if (SWIG_arg_fail(5)) SWIG_fail;
29085 }
29086 }
29087 {
29088 PyThreadState* __tstate = wxPyBeginAllowThreads();
29089 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29090
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 {
29095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29096 }
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29104 PyObject *resultobj;
29105 wxWindow *arg1 = (wxWindow *) 0 ;
29106 wxPoint *arg2 = 0 ;
29107 bool result;
29108 wxPoint temp2 ;
29109 PyObject * obj0 = 0 ;
29110 PyObject * obj1 = 0 ;
29111 char *kwnames[] = {
29112 (char *) "self",(char *) "pt", NULL
29113 };
29114
29115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29117 if (SWIG_arg_fail(1)) SWIG_fail;
29118 {
29119 arg2 = &temp2;
29120 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29121 }
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29125
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 {
29130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29131 }
29132 return resultobj;
29133 fail:
29134 return NULL;
29135 }
29136
29137
29138 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29139 PyObject *resultobj;
29140 wxWindow *arg1 = (wxWindow *) 0 ;
29141 wxRect *arg2 = 0 ;
29142 bool result;
29143 wxRect temp2 ;
29144 PyObject * obj0 = 0 ;
29145 PyObject * obj1 = 0 ;
29146 char *kwnames[] = {
29147 (char *) "self",(char *) "rect", NULL
29148 };
29149
29150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29152 if (SWIG_arg_fail(1)) SWIG_fail;
29153 {
29154 arg2 = &temp2;
29155 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29156 }
29157 {
29158 PyThreadState* __tstate = wxPyBeginAllowThreads();
29159 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29160
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 {
29165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29166 }
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj;
29175 wxWindow *arg1 = (wxWindow *) 0 ;
29176 wxVisualAttributes result;
29177 PyObject * obj0 = 0 ;
29178 char *kwnames[] = {
29179 (char *) "self", NULL
29180 };
29181
29182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29184 if (SWIG_arg_fail(1)) SWIG_fail;
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29188
29189 wxPyEndAllowThreads(__tstate);
29190 if (PyErr_Occurred()) SWIG_fail;
29191 }
29192 {
29193 wxVisualAttributes * resultptr;
29194 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29196 }
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj;
29205 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29206 wxVisualAttributes result;
29207 PyObject * obj0 = 0 ;
29208 char *kwnames[] = {
29209 (char *) "variant", NULL
29210 };
29211
29212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29213 if (obj0) {
29214 {
29215 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29216 if (SWIG_arg_fail(1)) SWIG_fail;
29217 }
29218 }
29219 {
29220 if (!wxPyCheckForApp()) SWIG_fail;
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29223
29224 wxPyEndAllowThreads(__tstate);
29225 if (PyErr_Occurred()) SWIG_fail;
29226 }
29227 {
29228 wxVisualAttributes * resultptr;
29229 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29231 }
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29239 PyObject *resultobj;
29240 wxWindow *arg1 = (wxWindow *) 0 ;
29241 wxColour *arg2 = 0 ;
29242 bool result;
29243 wxColour temp2 ;
29244 PyObject * obj0 = 0 ;
29245 PyObject * obj1 = 0 ;
29246 char *kwnames[] = {
29247 (char *) "self",(char *) "colour", NULL
29248 };
29249
29250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29252 if (SWIG_arg_fail(1)) SWIG_fail;
29253 {
29254 arg2 = &temp2;
29255 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29256 }
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29260
29261 wxPyEndAllowThreads(__tstate);
29262 if (PyErr_Occurred()) SWIG_fail;
29263 }
29264 {
29265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29266 }
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj;
29275 wxWindow *arg1 = (wxWindow *) 0 ;
29276 wxColour *arg2 = 0 ;
29277 wxColour temp2 ;
29278 PyObject * obj0 = 0 ;
29279 PyObject * obj1 = 0 ;
29280 char *kwnames[] = {
29281 (char *) "self",(char *) "colour", NULL
29282 };
29283
29284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29286 if (SWIG_arg_fail(1)) SWIG_fail;
29287 {
29288 arg2 = &temp2;
29289 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29290 }
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29294
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 Py_INCREF(Py_None); resultobj = Py_None;
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj;
29307 wxWindow *arg1 = (wxWindow *) 0 ;
29308 wxColour *arg2 = 0 ;
29309 bool result;
29310 wxColour temp2 ;
29311 PyObject * obj0 = 0 ;
29312 PyObject * obj1 = 0 ;
29313 char *kwnames[] = {
29314 (char *) "self",(char *) "colour", NULL
29315 };
29316
29317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29319 if (SWIG_arg_fail(1)) SWIG_fail;
29320 {
29321 arg2 = &temp2;
29322 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29323 }
29324 {
29325 PyThreadState* __tstate = wxPyBeginAllowThreads();
29326 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29327
29328 wxPyEndAllowThreads(__tstate);
29329 if (PyErr_Occurred()) SWIG_fail;
29330 }
29331 {
29332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29333 }
29334 return resultobj;
29335 fail:
29336 return NULL;
29337 }
29338
29339
29340 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29341 PyObject *resultobj;
29342 wxWindow *arg1 = (wxWindow *) 0 ;
29343 wxColour *arg2 = 0 ;
29344 wxColour temp2 ;
29345 PyObject * obj0 = 0 ;
29346 PyObject * obj1 = 0 ;
29347 char *kwnames[] = {
29348 (char *) "self",(char *) "colour", NULL
29349 };
29350
29351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
29356 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29357 }
29358 {
29359 PyThreadState* __tstate = wxPyBeginAllowThreads();
29360 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29361
29362 wxPyEndAllowThreads(__tstate);
29363 if (PyErr_Occurred()) SWIG_fail;
29364 }
29365 Py_INCREF(Py_None); resultobj = Py_None;
29366 return resultobj;
29367 fail:
29368 return NULL;
29369 }
29370
29371
29372 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29373 PyObject *resultobj;
29374 wxWindow *arg1 = (wxWindow *) 0 ;
29375 wxColour result;
29376 PyObject * obj0 = 0 ;
29377 char *kwnames[] = {
29378 (char *) "self", NULL
29379 };
29380
29381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29383 if (SWIG_arg_fail(1)) SWIG_fail;
29384 {
29385 PyThreadState* __tstate = wxPyBeginAllowThreads();
29386 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29387
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 {
29392 wxColour * resultptr;
29393 resultptr = new wxColour((wxColour &)(result));
29394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29395 }
29396 return resultobj;
29397 fail:
29398 return NULL;
29399 }
29400
29401
29402 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29403 PyObject *resultobj;
29404 wxWindow *arg1 = (wxWindow *) 0 ;
29405 wxColour result;
29406 PyObject * obj0 = 0 ;
29407 char *kwnames[] = {
29408 (char *) "self", NULL
29409 };
29410
29411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29413 if (SWIG_arg_fail(1)) SWIG_fail;
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = ((wxWindow const *)arg1)->GetForegroundColour();
29417
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 {
29422 wxColour * resultptr;
29423 resultptr = new wxColour((wxColour &)(result));
29424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29425 }
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxWindow *arg1 = (wxWindow *) 0 ;
29435 bool result;
29436 PyObject * obj0 = 0 ;
29437 char *kwnames[] = {
29438 (char *) "self", NULL
29439 };
29440
29441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29443 if (SWIG_arg_fail(1)) SWIG_fail;
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 {
29452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29453 }
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj;
29462 wxWindow *arg1 = (wxWindow *) 0 ;
29463 bool result;
29464 PyObject * obj0 = 0 ;
29465 char *kwnames[] = {
29466 (char *) "self", NULL
29467 };
29468
29469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29471 if (SWIG_arg_fail(1)) SWIG_fail;
29472 {
29473 PyThreadState* __tstate = wxPyBeginAllowThreads();
29474 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29475
29476 wxPyEndAllowThreads(__tstate);
29477 if (PyErr_Occurred()) SWIG_fail;
29478 }
29479 {
29480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29481 }
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29489 PyObject *resultobj;
29490 wxWindow *arg1 = (wxWindow *) 0 ;
29491 wxBackgroundStyle arg2 ;
29492 bool result;
29493 PyObject * obj0 = 0 ;
29494 PyObject * obj1 = 0 ;
29495 char *kwnames[] = {
29496 (char *) "self",(char *) "style", NULL
29497 };
29498
29499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29501 if (SWIG_arg_fail(1)) SWIG_fail;
29502 {
29503 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29504 if (SWIG_arg_fail(2)) SWIG_fail;
29505 }
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29509
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 {
29514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29515 }
29516 return resultobj;
29517 fail:
29518 return NULL;
29519 }
29520
29521
29522 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29523 PyObject *resultobj;
29524 wxWindow *arg1 = (wxWindow *) 0 ;
29525 wxBackgroundStyle result;
29526 PyObject * obj0 = 0 ;
29527 char *kwnames[] = {
29528 (char *) "self", NULL
29529 };
29530
29531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29533 if (SWIG_arg_fail(1)) SWIG_fail;
29534 {
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29537
29538 wxPyEndAllowThreads(__tstate);
29539 if (PyErr_Occurred()) SWIG_fail;
29540 }
29541 resultobj = SWIG_From_int((result));
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj;
29550 wxWindow *arg1 = (wxWindow *) 0 ;
29551 bool result;
29552 PyObject * obj0 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 {
29561 PyThreadState* __tstate = wxPyBeginAllowThreads();
29562 result = (bool)(arg1)->HasTransparentBackground();
29563
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 {
29568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29569 }
29570 return resultobj;
29571 fail:
29572 return NULL;
29573 }
29574
29575
29576 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29577 PyObject *resultobj;
29578 wxWindow *arg1 = (wxWindow *) 0 ;
29579 wxCursor *arg2 = 0 ;
29580 bool result;
29581 PyObject * obj0 = 0 ;
29582 PyObject * obj1 = 0 ;
29583 char *kwnames[] = {
29584 (char *) "self",(char *) "cursor", NULL
29585 };
29586
29587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29589 if (SWIG_arg_fail(1)) SWIG_fail;
29590 {
29591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29592 if (SWIG_arg_fail(2)) SWIG_fail;
29593 if (arg2 == NULL) {
29594 SWIG_null_ref("wxCursor");
29595 }
29596 if (SWIG_arg_fail(2)) SWIG_fail;
29597 }
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 {
29606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29607 }
29608 return resultobj;
29609 fail:
29610 return NULL;
29611 }
29612
29613
29614 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 wxCursor result;
29618 PyObject * obj0 = 0 ;
29619 char *kwnames[] = {
29620 (char *) "self", NULL
29621 };
29622
29623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29625 if (SWIG_arg_fail(1)) SWIG_fail;
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 result = (arg1)->GetCursor();
29629
29630 wxPyEndAllowThreads(__tstate);
29631 if (PyErr_Occurred()) SWIG_fail;
29632 }
29633 {
29634 wxCursor * resultptr;
29635 resultptr = new wxCursor((wxCursor &)(result));
29636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29637 }
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29645 PyObject *resultobj;
29646 wxWindow *arg1 = (wxWindow *) 0 ;
29647 wxFont *arg2 = 0 ;
29648 bool result;
29649 PyObject * obj0 = 0 ;
29650 PyObject * obj1 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self",(char *) "font", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29660 if (SWIG_arg_fail(2)) SWIG_fail;
29661 if (arg2 == NULL) {
29662 SWIG_null_ref("wxFont");
29663 }
29664 if (SWIG_arg_fail(2)) SWIG_fail;
29665 }
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29669
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 {
29674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29675 }
29676 return resultobj;
29677 fail:
29678 return NULL;
29679 }
29680
29681
29682 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29683 PyObject *resultobj;
29684 wxWindow *arg1 = (wxWindow *) 0 ;
29685 wxFont *arg2 = 0 ;
29686 PyObject * obj0 = 0 ;
29687 PyObject * obj1 = 0 ;
29688 char *kwnames[] = {
29689 (char *) "self",(char *) "font", NULL
29690 };
29691
29692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29694 if (SWIG_arg_fail(1)) SWIG_fail;
29695 {
29696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29697 if (SWIG_arg_fail(2)) SWIG_fail;
29698 if (arg2 == NULL) {
29699 SWIG_null_ref("wxFont");
29700 }
29701 if (SWIG_arg_fail(2)) SWIG_fail;
29702 }
29703 {
29704 PyThreadState* __tstate = wxPyBeginAllowThreads();
29705 (arg1)->SetOwnFont((wxFont const &)*arg2);
29706
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 Py_INCREF(Py_None); resultobj = Py_None;
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj;
29719 wxWindow *arg1 = (wxWindow *) 0 ;
29720 wxFont result;
29721 PyObject * obj0 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = (arg1)->GetFont();
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 wxFont * resultptr;
29738 resultptr = new wxFont((wxFont &)(result));
29739 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29740 }
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj;
29749 wxWindow *arg1 = (wxWindow *) 0 ;
29750 wxCaret *arg2 = (wxCaret *) 0 ;
29751 PyObject * obj0 = 0 ;
29752 PyObject * obj1 = 0 ;
29753 char *kwnames[] = {
29754 (char *) "self",(char *) "caret", NULL
29755 };
29756
29757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29759 if (SWIG_arg_fail(1)) SWIG_fail;
29760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(2)) SWIG_fail;
29762 {
29763 PyThreadState* __tstate = wxPyBeginAllowThreads();
29764 (arg1)->SetCaret(arg2);
29765
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 Py_INCREF(Py_None); resultobj = Py_None;
29770 return resultobj;
29771 fail:
29772 return NULL;
29773 }
29774
29775
29776 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29777 PyObject *resultobj;
29778 wxWindow *arg1 = (wxWindow *) 0 ;
29779 wxCaret *result;
29780 PyObject * obj0 = 0 ;
29781 char *kwnames[] = {
29782 (char *) "self", NULL
29783 };
29784
29785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29787 if (SWIG_arg_fail(1)) SWIG_fail;
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj;
29804 wxWindow *arg1 = (wxWindow *) 0 ;
29805 int result;
29806 PyObject * obj0 = 0 ;
29807 char *kwnames[] = {
29808 (char *) "self", NULL
29809 };
29810
29811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29813 if (SWIG_arg_fail(1)) SWIG_fail;
29814 {
29815 PyThreadState* __tstate = wxPyBeginAllowThreads();
29816 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29817
29818 wxPyEndAllowThreads(__tstate);
29819 if (PyErr_Occurred()) SWIG_fail;
29820 }
29821 {
29822 resultobj = SWIG_From_int((int)(result));
29823 }
29824 return resultobj;
29825 fail:
29826 return NULL;
29827 }
29828
29829
29830 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29831 PyObject *resultobj;
29832 wxWindow *arg1 = (wxWindow *) 0 ;
29833 int result;
29834 PyObject * obj0 = 0 ;
29835 char *kwnames[] = {
29836 (char *) "self", NULL
29837 };
29838
29839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29841 if (SWIG_arg_fail(1)) SWIG_fail;
29842 {
29843 PyThreadState* __tstate = wxPyBeginAllowThreads();
29844 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29845
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 {
29850 resultobj = SWIG_From_int((int)(result));
29851 }
29852 return resultobj;
29853 fail:
29854 return NULL;
29855 }
29856
29857
29858 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29859 PyObject *resultobj;
29860 wxWindow *arg1 = (wxWindow *) 0 ;
29861 wxString *arg2 = 0 ;
29862 int *arg3 = (int *) 0 ;
29863 int *arg4 = (int *) 0 ;
29864 bool temp2 = false ;
29865 int temp3 ;
29866 int res3 = 0 ;
29867 int temp4 ;
29868 int res4 = 0 ;
29869 PyObject * obj0 = 0 ;
29870 PyObject * obj1 = 0 ;
29871 char *kwnames[] = {
29872 (char *) "self",(char *) "string", NULL
29873 };
29874
29875 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29876 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29879 if (SWIG_arg_fail(1)) SWIG_fail;
29880 {
29881 arg2 = wxString_in_helper(obj1);
29882 if (arg2 == NULL) SWIG_fail;
29883 temp2 = true;
29884 }
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29888
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 Py_INCREF(Py_None); resultobj = Py_None;
29893 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29894 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29895 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29896 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29897 {
29898 if (temp2)
29899 delete arg2;
29900 }
29901 return resultobj;
29902 fail:
29903 {
29904 if (temp2)
29905 delete arg2;
29906 }
29907 return NULL;
29908 }
29909
29910
29911 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29912 PyObject *resultobj;
29913 wxWindow *arg1 = (wxWindow *) 0 ;
29914 wxString *arg2 = 0 ;
29915 int *arg3 = (int *) 0 ;
29916 int *arg4 = (int *) 0 ;
29917 int *arg5 = (int *) 0 ;
29918 int *arg6 = (int *) 0 ;
29919 wxFont *arg7 = (wxFont *) NULL ;
29920 bool temp2 = false ;
29921 int temp3 ;
29922 int res3 = 0 ;
29923 int temp4 ;
29924 int res4 = 0 ;
29925 int temp5 ;
29926 int res5 = 0 ;
29927 int temp6 ;
29928 int res6 = 0 ;
29929 PyObject * obj0 = 0 ;
29930 PyObject * obj1 = 0 ;
29931 PyObject * obj2 = 0 ;
29932 char *kwnames[] = {
29933 (char *) "self",(char *) "string",(char *) "font", NULL
29934 };
29935
29936 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29937 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29938 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29939 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29942 if (SWIG_arg_fail(1)) SWIG_fail;
29943 {
29944 arg2 = wxString_in_helper(obj1);
29945 if (arg2 == NULL) SWIG_fail;
29946 temp2 = true;
29947 }
29948 if (obj2) {
29949 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29950 if (SWIG_arg_fail(7)) SWIG_fail;
29951 }
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29955
29956 wxPyEndAllowThreads(__tstate);
29957 if (PyErr_Occurred()) SWIG_fail;
29958 }
29959 Py_INCREF(Py_None); resultobj = Py_None;
29960 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29961 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29962 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29963 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29964 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29965 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29966 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29967 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29968 {
29969 if (temp2)
29970 delete arg2;
29971 }
29972 return resultobj;
29973 fail:
29974 {
29975 if (temp2)
29976 delete arg2;
29977 }
29978 return NULL;
29979 }
29980
29981
29982 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj;
29984 wxWindow *arg1 = (wxWindow *) 0 ;
29985 int *arg2 = (int *) 0 ;
29986 int *arg3 = (int *) 0 ;
29987 int temp2 ;
29988 int res2 = 0 ;
29989 int temp3 ;
29990 int res3 = 0 ;
29991 PyObject * obj0 = 0 ;
29992 PyObject * obj1 = 0 ;
29993 PyObject * obj2 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self",(char *) "x",(char *) "y", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 {
30002 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30003 temp2 = SWIG_As_int(obj1);
30004 if (SWIG_arg_fail(2)) SWIG_fail;
30005 arg2 = &temp2;
30006 res2 = SWIG_NEWOBJ;
30007 }
30008 }
30009 {
30010 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30011 temp3 = SWIG_As_int(obj2);
30012 if (SWIG_arg_fail(3)) SWIG_fail;
30013 arg3 = &temp3;
30014 res3 = SWIG_NEWOBJ;
30015 }
30016 }
30017 {
30018 PyThreadState* __tstate = wxPyBeginAllowThreads();
30019 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30020
30021 wxPyEndAllowThreads(__tstate);
30022 if (PyErr_Occurred()) SWIG_fail;
30023 }
30024 Py_INCREF(Py_None); resultobj = Py_None;
30025 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30026 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30027 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30028 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30029 return resultobj;
30030 fail:
30031 return NULL;
30032 }
30033
30034
30035 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30036 PyObject *resultobj;
30037 wxWindow *arg1 = (wxWindow *) 0 ;
30038 int *arg2 = (int *) 0 ;
30039 int *arg3 = (int *) 0 ;
30040 int temp2 ;
30041 int res2 = 0 ;
30042 int temp3 ;
30043 int res3 = 0 ;
30044 PyObject * obj0 = 0 ;
30045 PyObject * obj1 = 0 ;
30046 PyObject * obj2 = 0 ;
30047 char *kwnames[] = {
30048 (char *) "self",(char *) "x",(char *) "y", NULL
30049 };
30050
30051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30053 if (SWIG_arg_fail(1)) SWIG_fail;
30054 {
30055 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30056 temp2 = SWIG_As_int(obj1);
30057 if (SWIG_arg_fail(2)) SWIG_fail;
30058 arg2 = &temp2;
30059 res2 = SWIG_NEWOBJ;
30060 }
30061 }
30062 {
30063 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30064 temp3 = SWIG_As_int(obj2);
30065 if (SWIG_arg_fail(3)) SWIG_fail;
30066 arg3 = &temp3;
30067 res3 = SWIG_NEWOBJ;
30068 }
30069 }
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30073
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 Py_INCREF(Py_None); resultobj = Py_None;
30078 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30079 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30080 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30081 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj;
30090 wxWindow *arg1 = (wxWindow *) 0 ;
30091 wxPoint *arg2 = 0 ;
30092 wxPoint result;
30093 wxPoint temp2 ;
30094 PyObject * obj0 = 0 ;
30095 PyObject * obj1 = 0 ;
30096 char *kwnames[] = {
30097 (char *) "self",(char *) "pt", NULL
30098 };
30099
30100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30102 if (SWIG_arg_fail(1)) SWIG_fail;
30103 {
30104 arg2 = &temp2;
30105 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30106 }
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30110
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 {
30115 wxPoint * resultptr;
30116 resultptr = new wxPoint((wxPoint &)(result));
30117 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30118 }
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj;
30127 wxWindow *arg1 = (wxWindow *) 0 ;
30128 wxPoint *arg2 = 0 ;
30129 wxPoint result;
30130 wxPoint temp2 ;
30131 PyObject * obj0 = 0 ;
30132 PyObject * obj1 = 0 ;
30133 char *kwnames[] = {
30134 (char *) "self",(char *) "pt", NULL
30135 };
30136
30137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30139 if (SWIG_arg_fail(1)) SWIG_fail;
30140 {
30141 arg2 = &temp2;
30142 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30143 }
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30147
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 {
30152 wxPoint * resultptr;
30153 resultptr = new wxPoint((wxPoint &)(result));
30154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30155 }
30156 return resultobj;
30157 fail:
30158 return NULL;
30159 }
30160
30161
30162 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30163 PyObject *resultobj;
30164 wxWindow *arg1 = (wxWindow *) 0 ;
30165 int arg2 ;
30166 int arg3 ;
30167 wxHitTest result;
30168 PyObject * obj0 = 0 ;
30169 PyObject * obj1 = 0 ;
30170 PyObject * obj2 = 0 ;
30171 char *kwnames[] = {
30172 (char *) "self",(char *) "x",(char *) "y", NULL
30173 };
30174
30175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30177 if (SWIG_arg_fail(1)) SWIG_fail;
30178 {
30179 arg2 = (int)(SWIG_As_int(obj1));
30180 if (SWIG_arg_fail(2)) SWIG_fail;
30181 }
30182 {
30183 arg3 = (int)(SWIG_As_int(obj2));
30184 if (SWIG_arg_fail(3)) SWIG_fail;
30185 }
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30189
30190 wxPyEndAllowThreads(__tstate);
30191 if (PyErr_Occurred()) SWIG_fail;
30192 }
30193 resultobj = SWIG_From_int((result));
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj;
30202 wxWindow *arg1 = (wxWindow *) 0 ;
30203 wxPoint *arg2 = 0 ;
30204 wxHitTest result;
30205 wxPoint temp2 ;
30206 PyObject * obj0 = 0 ;
30207 PyObject * obj1 = 0 ;
30208 char *kwnames[] = {
30209 (char *) "self",(char *) "pt", NULL
30210 };
30211
30212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30214 if (SWIG_arg_fail(1)) SWIG_fail;
30215 {
30216 arg2 = &temp2;
30217 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30222
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 resultobj = SWIG_From_int((result));
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30234 PyObject *resultobj;
30235 wxWindow *arg1 = (wxWindow *) 0 ;
30236 long arg2 ;
30237 wxBorder result;
30238 PyObject * obj0 = 0 ;
30239 PyObject * obj1 = 0 ;
30240
30241 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30243 if (SWIG_arg_fail(1)) SWIG_fail;
30244 {
30245 arg2 = (long)(SWIG_As_long(obj1));
30246 if (SWIG_arg_fail(2)) SWIG_fail;
30247 }
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30251
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 resultobj = SWIG_From_int((result));
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30263 PyObject *resultobj;
30264 wxWindow *arg1 = (wxWindow *) 0 ;
30265 wxBorder result;
30266 PyObject * obj0 = 0 ;
30267
30268 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30274
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 resultobj = SWIG_From_int((result));
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30286 int argc;
30287 PyObject *argv[3];
30288 int ii;
30289
30290 argc = PyObject_Length(args);
30291 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30292 argv[ii] = PyTuple_GetItem(args,ii);
30293 }
30294 if (argc == 1) {
30295 int _v;
30296 {
30297 void *ptr;
30298 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30299 _v = 0;
30300 PyErr_Clear();
30301 } else {
30302 _v = 1;
30303 }
30304 }
30305 if (_v) {
30306 return _wrap_Window_GetBorder__SWIG_1(self,args);
30307 }
30308 }
30309 if (argc == 2) {
30310 int _v;
30311 {
30312 void *ptr;
30313 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30314 _v = 0;
30315 PyErr_Clear();
30316 } else {
30317 _v = 1;
30318 }
30319 }
30320 if (_v) {
30321 _v = SWIG_Check_long(argv[1]);
30322 if (_v) {
30323 return _wrap_Window_GetBorder__SWIG_0(self,args);
30324 }
30325 }
30326 }
30327
30328 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30329 return NULL;
30330 }
30331
30332
30333 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj;
30335 wxWindow *arg1 = (wxWindow *) 0 ;
30336 long arg2 = (long) wxUPDATE_UI_NONE ;
30337 PyObject * obj0 = 0 ;
30338 PyObject * obj1 = 0 ;
30339 char *kwnames[] = {
30340 (char *) "self",(char *) "flags", NULL
30341 };
30342
30343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30345 if (SWIG_arg_fail(1)) SWIG_fail;
30346 if (obj1) {
30347 {
30348 arg2 = (long)(SWIG_As_long(obj1));
30349 if (SWIG_arg_fail(2)) SWIG_fail;
30350 }
30351 }
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 (arg1)->UpdateWindowUI(arg2);
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 Py_INCREF(Py_None); resultobj = Py_None;
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj;
30368 wxWindow *arg1 = (wxWindow *) 0 ;
30369 wxMenu *arg2 = (wxMenu *) 0 ;
30370 int arg3 = (int) -1 ;
30371 int arg4 = (int) -1 ;
30372 bool result;
30373 PyObject * obj0 = 0 ;
30374 PyObject * obj1 = 0 ;
30375 PyObject * obj2 = 0 ;
30376 PyObject * obj3 = 0 ;
30377 char *kwnames[] = {
30378 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30379 };
30380
30381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30383 if (SWIG_arg_fail(1)) SWIG_fail;
30384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30385 if (SWIG_arg_fail(2)) SWIG_fail;
30386 if (obj2) {
30387 {
30388 arg3 = (int)(SWIG_As_int(obj2));
30389 if (SWIG_arg_fail(3)) SWIG_fail;
30390 }
30391 }
30392 if (obj3) {
30393 {
30394 arg4 = (int)(SWIG_As_int(obj3));
30395 if (SWIG_arg_fail(4)) SWIG_fail;
30396 }
30397 }
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30401
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 {
30406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30407 }
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30415 PyObject *resultobj;
30416 wxWindow *arg1 = (wxWindow *) 0 ;
30417 wxMenu *arg2 = (wxMenu *) 0 ;
30418 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30419 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30420 bool result;
30421 wxPoint temp3 ;
30422 PyObject * obj0 = 0 ;
30423 PyObject * obj1 = 0 ;
30424 PyObject * obj2 = 0 ;
30425 char *kwnames[] = {
30426 (char *) "self",(char *) "menu",(char *) "pos", NULL
30427 };
30428
30429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30431 if (SWIG_arg_fail(1)) SWIG_fail;
30432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30433 if (SWIG_arg_fail(2)) SWIG_fail;
30434 if (obj2) {
30435 {
30436 arg3 = &temp3;
30437 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30438 }
30439 }
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30443
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 {
30448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30449 }
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30457 PyObject *resultobj;
30458 wxWindow *arg1 = (wxWindow *) 0 ;
30459 long result;
30460 PyObject * obj0 = 0 ;
30461 char *kwnames[] = {
30462 (char *) "self", NULL
30463 };
30464
30465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30467 if (SWIG_arg_fail(1)) SWIG_fail;
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 result = (long)wxWindow_GetHandle(arg1);
30471
30472 wxPyEndAllowThreads(__tstate);
30473 if (PyErr_Occurred()) SWIG_fail;
30474 }
30475 {
30476 resultobj = SWIG_From_long((long)(result));
30477 }
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30485 PyObject *resultobj;
30486 wxWindow *arg1 = (wxWindow *) 0 ;
30487 long arg2 ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 char *kwnames[] = {
30491 (char *) "self",(char *) "handle", NULL
30492 };
30493
30494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30496 if (SWIG_arg_fail(1)) SWIG_fail;
30497 {
30498 arg2 = (long)(SWIG_As_long(obj1));
30499 if (SWIG_arg_fail(2)) SWIG_fail;
30500 }
30501 {
30502 PyThreadState* __tstate = wxPyBeginAllowThreads();
30503 wxWindow_AssociateHandle(arg1,arg2);
30504
30505 wxPyEndAllowThreads(__tstate);
30506 if (PyErr_Occurred()) SWIG_fail;
30507 }
30508 Py_INCREF(Py_None); resultobj = Py_None;
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxWindow *arg1 = (wxWindow *) 0 ;
30518 PyObject * obj0 = 0 ;
30519 char *kwnames[] = {
30520 (char *) "self", NULL
30521 };
30522
30523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30525 if (SWIG_arg_fail(1)) SWIG_fail;
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 (arg1)->DissociateHandle();
30529
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 Py_INCREF(Py_None); resultobj = Py_None;
30534 return resultobj;
30535 fail:
30536 return NULL;
30537 }
30538
30539
30540 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30541 PyObject *resultobj;
30542 wxWindow *arg1 = (wxWindow *) 0 ;
30543 int arg2 ;
30544 bool result;
30545 PyObject * obj0 = 0 ;
30546 PyObject * obj1 = 0 ;
30547 char *kwnames[] = {
30548 (char *) "self",(char *) "orient", NULL
30549 };
30550
30551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30553 if (SWIG_arg_fail(1)) SWIG_fail;
30554 {
30555 arg2 = (int)(SWIG_As_int(obj1));
30556 if (SWIG_arg_fail(2)) SWIG_fail;
30557 }
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30561
30562 wxPyEndAllowThreads(__tstate);
30563 if (PyErr_Occurred()) SWIG_fail;
30564 }
30565 {
30566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30567 }
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj;
30576 wxWindow *arg1 = (wxWindow *) 0 ;
30577 int arg2 ;
30578 int arg3 ;
30579 int arg4 ;
30580 int arg5 ;
30581 bool arg6 = (bool) true ;
30582 PyObject * obj0 = 0 ;
30583 PyObject * obj1 = 0 ;
30584 PyObject * obj2 = 0 ;
30585 PyObject * obj3 = 0 ;
30586 PyObject * obj4 = 0 ;
30587 PyObject * obj5 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 {
30596 arg2 = (int)(SWIG_As_int(obj1));
30597 if (SWIG_arg_fail(2)) SWIG_fail;
30598 }
30599 {
30600 arg3 = (int)(SWIG_As_int(obj2));
30601 if (SWIG_arg_fail(3)) SWIG_fail;
30602 }
30603 {
30604 arg4 = (int)(SWIG_As_int(obj3));
30605 if (SWIG_arg_fail(4)) SWIG_fail;
30606 }
30607 {
30608 arg5 = (int)(SWIG_As_int(obj4));
30609 if (SWIG_arg_fail(5)) SWIG_fail;
30610 }
30611 if (obj5) {
30612 {
30613 arg6 = (bool)(SWIG_As_bool(obj5));
30614 if (SWIG_arg_fail(6)) SWIG_fail;
30615 }
30616 }
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30620
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 Py_INCREF(Py_None); resultobj = Py_None;
30625 return resultobj;
30626 fail:
30627 return NULL;
30628 }
30629
30630
30631 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30632 PyObject *resultobj;
30633 wxWindow *arg1 = (wxWindow *) 0 ;
30634 int arg2 ;
30635 int arg3 ;
30636 bool arg4 = (bool) true ;
30637 PyObject * obj0 = 0 ;
30638 PyObject * obj1 = 0 ;
30639 PyObject * obj2 = 0 ;
30640 PyObject * obj3 = 0 ;
30641 char *kwnames[] = {
30642 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30643 };
30644
30645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30647 if (SWIG_arg_fail(1)) SWIG_fail;
30648 {
30649 arg2 = (int)(SWIG_As_int(obj1));
30650 if (SWIG_arg_fail(2)) SWIG_fail;
30651 }
30652 {
30653 arg3 = (int)(SWIG_As_int(obj2));
30654 if (SWIG_arg_fail(3)) SWIG_fail;
30655 }
30656 if (obj3) {
30657 {
30658 arg4 = (bool)(SWIG_As_bool(obj3));
30659 if (SWIG_arg_fail(4)) SWIG_fail;
30660 }
30661 }
30662 {
30663 PyThreadState* __tstate = wxPyBeginAllowThreads();
30664 (arg1)->SetScrollPos(arg2,arg3,arg4);
30665
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 Py_INCREF(Py_None); resultobj = Py_None;
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj;
30678 wxWindow *arg1 = (wxWindow *) 0 ;
30679 int arg2 ;
30680 int result;
30681 PyObject * obj0 = 0 ;
30682 PyObject * obj1 = 0 ;
30683 char *kwnames[] = {
30684 (char *) "self",(char *) "orientation", NULL
30685 };
30686
30687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30689 if (SWIG_arg_fail(1)) SWIG_fail;
30690 {
30691 arg2 = (int)(SWIG_As_int(obj1));
30692 if (SWIG_arg_fail(2)) SWIG_fail;
30693 }
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 {
30702 resultobj = SWIG_From_int((int)(result));
30703 }
30704 return resultobj;
30705 fail:
30706 return NULL;
30707 }
30708
30709
30710 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30711 PyObject *resultobj;
30712 wxWindow *arg1 = (wxWindow *) 0 ;
30713 int arg2 ;
30714 int result;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717 char *kwnames[] = {
30718 (char *) "self",(char *) "orientation", NULL
30719 };
30720
30721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 arg2 = (int)(SWIG_As_int(obj1));
30726 if (SWIG_arg_fail(2)) SWIG_fail;
30727 }
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30731
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 {
30736 resultobj = SWIG_From_int((int)(result));
30737 }
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30745 PyObject *resultobj;
30746 wxWindow *arg1 = (wxWindow *) 0 ;
30747 int arg2 ;
30748 int result;
30749 PyObject * obj0 = 0 ;
30750 PyObject * obj1 = 0 ;
30751 char *kwnames[] = {
30752 (char *) "self",(char *) "orientation", NULL
30753 };
30754
30755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30757 if (SWIG_arg_fail(1)) SWIG_fail;
30758 {
30759 arg2 = (int)(SWIG_As_int(obj1));
30760 if (SWIG_arg_fail(2)) SWIG_fail;
30761 }
30762 {
30763 PyThreadState* __tstate = wxPyBeginAllowThreads();
30764 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30765
30766 wxPyEndAllowThreads(__tstate);
30767 if (PyErr_Occurred()) SWIG_fail;
30768 }
30769 {
30770 resultobj = SWIG_From_int((int)(result));
30771 }
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj;
30780 wxWindow *arg1 = (wxWindow *) 0 ;
30781 int arg2 ;
30782 int arg3 ;
30783 wxRect *arg4 = (wxRect *) NULL ;
30784 PyObject * obj0 = 0 ;
30785 PyObject * obj1 = 0 ;
30786 PyObject * obj2 = 0 ;
30787 PyObject * obj3 = 0 ;
30788 char *kwnames[] = {
30789 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30790 };
30791
30792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30794 if (SWIG_arg_fail(1)) SWIG_fail;
30795 {
30796 arg2 = (int)(SWIG_As_int(obj1));
30797 if (SWIG_arg_fail(2)) SWIG_fail;
30798 }
30799 {
30800 arg3 = (int)(SWIG_As_int(obj2));
30801 if (SWIG_arg_fail(3)) SWIG_fail;
30802 }
30803 if (obj3) {
30804 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30805 if (SWIG_arg_fail(4)) SWIG_fail;
30806 }
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30810
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 Py_INCREF(Py_None); resultobj = Py_None;
30815 return resultobj;
30816 fail:
30817 return NULL;
30818 }
30819
30820
30821 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30822 PyObject *resultobj;
30823 wxWindow *arg1 = (wxWindow *) 0 ;
30824 int arg2 ;
30825 bool result;
30826 PyObject * obj0 = 0 ;
30827 PyObject * obj1 = 0 ;
30828 char *kwnames[] = {
30829 (char *) "self",(char *) "lines", NULL
30830 };
30831
30832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(1)) SWIG_fail;
30835 {
30836 arg2 = (int)(SWIG_As_int(obj1));
30837 if (SWIG_arg_fail(2)) SWIG_fail;
30838 }
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (bool)(arg1)->ScrollLines(arg2);
30842
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 {
30847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30856 PyObject *resultobj;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 int arg2 ;
30859 bool result;
30860 PyObject * obj0 = 0 ;
30861 PyObject * obj1 = 0 ;
30862 char *kwnames[] = {
30863 (char *) "self",(char *) "pages", NULL
30864 };
30865
30866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30868 if (SWIG_arg_fail(1)) SWIG_fail;
30869 {
30870 arg2 = (int)(SWIG_As_int(obj1));
30871 if (SWIG_arg_fail(2)) SWIG_fail;
30872 }
30873 {
30874 PyThreadState* __tstate = wxPyBeginAllowThreads();
30875 result = (bool)(arg1)->ScrollPages(arg2);
30876
30877 wxPyEndAllowThreads(__tstate);
30878 if (PyErr_Occurred()) SWIG_fail;
30879 }
30880 {
30881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30882 }
30883 return resultobj;
30884 fail:
30885 return NULL;
30886 }
30887
30888
30889 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30890 PyObject *resultobj;
30891 wxWindow *arg1 = (wxWindow *) 0 ;
30892 bool result;
30893 PyObject * obj0 = 0 ;
30894 char *kwnames[] = {
30895 (char *) "self", NULL
30896 };
30897
30898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30900 if (SWIG_arg_fail(1)) SWIG_fail;
30901 {
30902 PyThreadState* __tstate = wxPyBeginAllowThreads();
30903 result = (bool)(arg1)->LineUp();
30904
30905 wxPyEndAllowThreads(__tstate);
30906 if (PyErr_Occurred()) SWIG_fail;
30907 }
30908 {
30909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30910 }
30911 return resultobj;
30912 fail:
30913 return NULL;
30914 }
30915
30916
30917 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30918 PyObject *resultobj;
30919 wxWindow *arg1 = (wxWindow *) 0 ;
30920 bool result;
30921 PyObject * obj0 = 0 ;
30922 char *kwnames[] = {
30923 (char *) "self", NULL
30924 };
30925
30926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30928 if (SWIG_arg_fail(1)) SWIG_fail;
30929 {
30930 PyThreadState* __tstate = wxPyBeginAllowThreads();
30931 result = (bool)(arg1)->LineDown();
30932
30933 wxPyEndAllowThreads(__tstate);
30934 if (PyErr_Occurred()) SWIG_fail;
30935 }
30936 {
30937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30938 }
30939 return resultobj;
30940 fail:
30941 return NULL;
30942 }
30943
30944
30945 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30946 PyObject *resultobj;
30947 wxWindow *arg1 = (wxWindow *) 0 ;
30948 bool result;
30949 PyObject * obj0 = 0 ;
30950 char *kwnames[] = {
30951 (char *) "self", NULL
30952 };
30953
30954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30956 if (SWIG_arg_fail(1)) SWIG_fail;
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 result = (bool)(arg1)->PageUp();
30960
30961 wxPyEndAllowThreads(__tstate);
30962 if (PyErr_Occurred()) SWIG_fail;
30963 }
30964 {
30965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30966 }
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30974 PyObject *resultobj;
30975 wxWindow *arg1 = (wxWindow *) 0 ;
30976 bool result;
30977 PyObject * obj0 = 0 ;
30978 char *kwnames[] = {
30979 (char *) "self", NULL
30980 };
30981
30982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30984 if (SWIG_arg_fail(1)) SWIG_fail;
30985 {
30986 PyThreadState* __tstate = wxPyBeginAllowThreads();
30987 result = (bool)(arg1)->PageDown();
30988
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 {
30993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30994 }
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31002 PyObject *resultobj;
31003 wxWindow *arg1 = (wxWindow *) 0 ;
31004 wxString *arg2 = 0 ;
31005 bool temp2 = false ;
31006 PyObject * obj0 = 0 ;
31007 PyObject * obj1 = 0 ;
31008 char *kwnames[] = {
31009 (char *) "self",(char *) "text", NULL
31010 };
31011
31012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31014 if (SWIG_arg_fail(1)) SWIG_fail;
31015 {
31016 arg2 = wxString_in_helper(obj1);
31017 if (arg2 == NULL) SWIG_fail;
31018 temp2 = true;
31019 }
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 (arg1)->SetHelpText((wxString const &)*arg2);
31023
31024 wxPyEndAllowThreads(__tstate);
31025 if (PyErr_Occurred()) SWIG_fail;
31026 }
31027 Py_INCREF(Py_None); resultobj = Py_None;
31028 {
31029 if (temp2)
31030 delete arg2;
31031 }
31032 return resultobj;
31033 fail:
31034 {
31035 if (temp2)
31036 delete arg2;
31037 }
31038 return NULL;
31039 }
31040
31041
31042 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31043 PyObject *resultobj;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 wxString *arg2 = 0 ;
31046 bool temp2 = false ;
31047 PyObject * obj0 = 0 ;
31048 PyObject * obj1 = 0 ;
31049 char *kwnames[] = {
31050 (char *) "self",(char *) "text", NULL
31051 };
31052
31053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31055 if (SWIG_arg_fail(1)) SWIG_fail;
31056 {
31057 arg2 = wxString_in_helper(obj1);
31058 if (arg2 == NULL) SWIG_fail;
31059 temp2 = true;
31060 }
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31064
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 Py_INCREF(Py_None); resultobj = Py_None;
31069 {
31070 if (temp2)
31071 delete arg2;
31072 }
31073 return resultobj;
31074 fail:
31075 {
31076 if (temp2)
31077 delete arg2;
31078 }
31079 return NULL;
31080 }
31081
31082
31083 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj;
31085 wxWindow *arg1 = (wxWindow *) 0 ;
31086 wxString result;
31087 PyObject * obj0 = 0 ;
31088 char *kwnames[] = {
31089 (char *) "self", NULL
31090 };
31091
31092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(1)) SWIG_fail;
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 result = ((wxWindow const *)arg1)->GetHelpText();
31098
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 {
31103 #if wxUSE_UNICODE
31104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31105 #else
31106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31107 #endif
31108 }
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 wxString *arg2 = 0 ;
31119 bool temp2 = false ;
31120 PyObject * obj0 = 0 ;
31121 PyObject * obj1 = 0 ;
31122 char *kwnames[] = {
31123 (char *) "self",(char *) "tip", NULL
31124 };
31125
31126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31128 if (SWIG_arg_fail(1)) SWIG_fail;
31129 {
31130 arg2 = wxString_in_helper(obj1);
31131 if (arg2 == NULL) SWIG_fail;
31132 temp2 = true;
31133 }
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 (arg1)->SetToolTip((wxString const &)*arg2);
31137
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 Py_INCREF(Py_None); resultobj = Py_None;
31142 {
31143 if (temp2)
31144 delete arg2;
31145 }
31146 return resultobj;
31147 fail:
31148 {
31149 if (temp2)
31150 delete arg2;
31151 }
31152 return NULL;
31153 }
31154
31155
31156 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj;
31158 wxWindow *arg1 = (wxWindow *) 0 ;
31159 wxToolTip *arg2 = (wxToolTip *) 0 ;
31160 PyObject * obj0 = 0 ;
31161 PyObject * obj1 = 0 ;
31162 char *kwnames[] = {
31163 (char *) "self",(char *) "tip", NULL
31164 };
31165
31166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31168 if (SWIG_arg_fail(1)) SWIG_fail;
31169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31170 if (SWIG_arg_fail(2)) SWIG_fail;
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 (arg1)->SetToolTip(arg2);
31174
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 Py_INCREF(Py_None); resultobj = Py_None;
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31186 PyObject *resultobj;
31187 wxWindow *arg1 = (wxWindow *) 0 ;
31188 wxToolTip *result;
31189 PyObject * obj0 = 0 ;
31190 char *kwnames[] = {
31191 (char *) "self", NULL
31192 };
31193
31194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31196 if (SWIG_arg_fail(1)) SWIG_fail;
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31200
31201 wxPyEndAllowThreads(__tstate);
31202 if (PyErr_Occurred()) SWIG_fail;
31203 }
31204 {
31205 resultobj = wxPyMake_wxObject(result, 0);
31206 }
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj;
31215 wxWindow *arg1 = (wxWindow *) 0 ;
31216 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31217 PyObject * obj0 = 0 ;
31218 PyObject * obj1 = 0 ;
31219 char *kwnames[] = {
31220 (char *) "self",(char *) "dropTarget", NULL
31221 };
31222
31223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31225 if (SWIG_arg_fail(1)) SWIG_fail;
31226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31227 if (SWIG_arg_fail(2)) SWIG_fail;
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 (arg1)->SetDropTarget(arg2);
31231
31232 wxPyEndAllowThreads(__tstate);
31233 if (PyErr_Occurred()) SWIG_fail;
31234 }
31235 Py_INCREF(Py_None); resultobj = Py_None;
31236 return resultobj;
31237 fail:
31238 return NULL;
31239 }
31240
31241
31242 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31243 PyObject *resultobj;
31244 wxWindow *arg1 = (wxWindow *) 0 ;
31245 wxPyDropTarget *result;
31246 PyObject * obj0 = 0 ;
31247 char *kwnames[] = {
31248 (char *) "self", NULL
31249 };
31250
31251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31253 if (SWIG_arg_fail(1)) SWIG_fail;
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31257
31258 wxPyEndAllowThreads(__tstate);
31259 if (PyErr_Occurred()) SWIG_fail;
31260 }
31261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj;
31270 wxWindow *arg1 = (wxWindow *) 0 ;
31271 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31272 PyObject * obj0 = 0 ;
31273 PyObject * obj1 = 0 ;
31274 char *kwnames[] = {
31275 (char *) "self",(char *) "constraints", NULL
31276 };
31277
31278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31280 if (SWIG_arg_fail(1)) SWIG_fail;
31281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31282 if (SWIG_arg_fail(2)) SWIG_fail;
31283 {
31284 PyThreadState* __tstate = wxPyBeginAllowThreads();
31285 (arg1)->SetConstraints(arg2);
31286
31287 wxPyEndAllowThreads(__tstate);
31288 if (PyErr_Occurred()) SWIG_fail;
31289 }
31290 Py_INCREF(Py_None); resultobj = Py_None;
31291 return resultobj;
31292 fail:
31293 return NULL;
31294 }
31295
31296
31297 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31298 PyObject *resultobj;
31299 wxWindow *arg1 = (wxWindow *) 0 ;
31300 wxLayoutConstraints *result;
31301 PyObject * obj0 = 0 ;
31302 char *kwnames[] = {
31303 (char *) "self", NULL
31304 };
31305
31306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31308 if (SWIG_arg_fail(1)) SWIG_fail;
31309 {
31310 PyThreadState* __tstate = wxPyBeginAllowThreads();
31311 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31312
31313 wxPyEndAllowThreads(__tstate);
31314 if (PyErr_Occurred()) SWIG_fail;
31315 }
31316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31317 return resultobj;
31318 fail:
31319 return NULL;
31320 }
31321
31322
31323 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31324 PyObject *resultobj;
31325 wxWindow *arg1 = (wxWindow *) 0 ;
31326 bool arg2 ;
31327 PyObject * obj0 = 0 ;
31328 PyObject * obj1 = 0 ;
31329 char *kwnames[] = {
31330 (char *) "self",(char *) "autoLayout", NULL
31331 };
31332
31333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31335 if (SWIG_arg_fail(1)) SWIG_fail;
31336 {
31337 arg2 = (bool)(SWIG_As_bool(obj1));
31338 if (SWIG_arg_fail(2)) SWIG_fail;
31339 }
31340 {
31341 PyThreadState* __tstate = wxPyBeginAllowThreads();
31342 (arg1)->SetAutoLayout(arg2);
31343
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 Py_INCREF(Py_None); resultobj = Py_None;
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 static PyObject *_wrap_Window_GetAutoLayout(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_GetAutoLayout",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)((wxWindow const *)arg1)->GetAutoLayout();
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_Layout(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_Layout",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)->Layout();
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_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31411 PyObject *resultobj;
31412 wxWindow *arg1 = (wxWindow *) 0 ;
31413 wxSizer *arg2 = (wxSizer *) 0 ;
31414 bool arg3 = (bool) true ;
31415 PyObject * obj0 = 0 ;
31416 PyObject * obj1 = 0 ;
31417 PyObject * obj2 = 0 ;
31418 char *kwnames[] = {
31419 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31420 };
31421
31422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31424 if (SWIG_arg_fail(1)) SWIG_fail;
31425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31426 if (SWIG_arg_fail(2)) SWIG_fail;
31427 if (obj2) {
31428 {
31429 arg3 = (bool)(SWIG_As_bool(obj2));
31430 if (SWIG_arg_fail(3)) SWIG_fail;
31431 }
31432 }
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 (arg1)->SetSizer(arg2,arg3);
31436
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 Py_INCREF(Py_None); resultobj = Py_None;
31441 return resultobj;
31442 fail:
31443 return NULL;
31444 }
31445
31446
31447 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31448 PyObject *resultobj;
31449 wxWindow *arg1 = (wxWindow *) 0 ;
31450 wxSizer *arg2 = (wxSizer *) 0 ;
31451 bool arg3 = (bool) true ;
31452 PyObject * obj0 = 0 ;
31453 PyObject * obj1 = 0 ;
31454 PyObject * obj2 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31463 if (SWIG_arg_fail(2)) SWIG_fail;
31464 if (obj2) {
31465 {
31466 arg3 = (bool)(SWIG_As_bool(obj2));
31467 if (SWIG_arg_fail(3)) SWIG_fail;
31468 }
31469 }
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 (arg1)->SetSizerAndFit(arg2,arg3);
31473
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 Py_INCREF(Py_None); resultobj = Py_None;
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 wxSizer *result;
31488 PyObject * obj0 = 0 ;
31489 char *kwnames[] = {
31490 (char *) "self", NULL
31491 };
31492
31493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31495 if (SWIG_arg_fail(1)) SWIG_fail;
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 {
31504 resultobj = wxPyMake_wxSizer(result, 0);
31505 }
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj;
31514 wxWindow *arg1 = (wxWindow *) 0 ;
31515 wxSizer *arg2 = (wxSizer *) 0 ;
31516 PyObject * obj0 = 0 ;
31517 PyObject * obj1 = 0 ;
31518 char *kwnames[] = {
31519 (char *) "self",(char *) "sizer", NULL
31520 };
31521
31522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31524 if (SWIG_arg_fail(1)) SWIG_fail;
31525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31526 if (SWIG_arg_fail(2)) SWIG_fail;
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 (arg1)->SetContainingSizer(arg2);
31530
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 Py_INCREF(Py_None); resultobj = Py_None;
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 wxSizer *result;
31545 PyObject * obj0 = 0 ;
31546 char *kwnames[] = {
31547 (char *) "self", NULL
31548 };
31549
31550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31552 if (SWIG_arg_fail(1)) SWIG_fail;
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31556
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 {
31561 resultobj = wxPyMake_wxSizer(result, 0);
31562 }
31563 return resultobj;
31564 fail:
31565 return NULL;
31566 }
31567
31568
31569 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31570 PyObject *resultobj;
31571 wxWindow *arg1 = (wxWindow *) 0 ;
31572 PyObject * obj0 = 0 ;
31573 char *kwnames[] = {
31574 (char *) "self", NULL
31575 };
31576
31577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31579 if (SWIG_arg_fail(1)) SWIG_fail;
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 (arg1)->InheritAttributes();
31583
31584 wxPyEndAllowThreads(__tstate);
31585 if (PyErr_Occurred()) SWIG_fail;
31586 }
31587 Py_INCREF(Py_None); resultobj = Py_None;
31588 return resultobj;
31589 fail:
31590 return NULL;
31591 }
31592
31593
31594 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31595 PyObject *resultobj;
31596 wxWindow *arg1 = (wxWindow *) 0 ;
31597 bool result;
31598 PyObject * obj0 = 0 ;
31599 char *kwnames[] = {
31600 (char *) "self", NULL
31601 };
31602
31603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31605 if (SWIG_arg_fail(1)) SWIG_fail;
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31609
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 {
31614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31615 }
31616 return resultobj;
31617 fail:
31618 return NULL;
31619 }
31620
31621
31622 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31623 PyObject *obj;
31624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31625 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31626 Py_INCREF(obj);
31627 return Py_BuildValue((char *)"");
31628 }
31629 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31630 PyObject *resultobj;
31631 long arg1 ;
31632 wxWindow *arg2 = (wxWindow *) NULL ;
31633 wxWindow *result;
31634 PyObject * obj0 = 0 ;
31635 PyObject * obj1 = 0 ;
31636 char *kwnames[] = {
31637 (char *) "id",(char *) "parent", NULL
31638 };
31639
31640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31641 {
31642 arg1 = (long)(SWIG_As_long(obj0));
31643 if (SWIG_arg_fail(1)) SWIG_fail;
31644 }
31645 if (obj1) {
31646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31647 if (SWIG_arg_fail(2)) SWIG_fail;
31648 }
31649 {
31650 if (!wxPyCheckForApp()) SWIG_fail;
31651 PyThreadState* __tstate = wxPyBeginAllowThreads();
31652 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31653
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 {
31658 resultobj = wxPyMake_wxObject(result, 0);
31659 }
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31667 PyObject *resultobj;
31668 wxString *arg1 = 0 ;
31669 wxWindow *arg2 = (wxWindow *) NULL ;
31670 wxWindow *result;
31671 bool temp1 = false ;
31672 PyObject * obj0 = 0 ;
31673 PyObject * obj1 = 0 ;
31674 char *kwnames[] = {
31675 (char *) "name",(char *) "parent", NULL
31676 };
31677
31678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31679 {
31680 arg1 = wxString_in_helper(obj0);
31681 if (arg1 == NULL) SWIG_fail;
31682 temp1 = true;
31683 }
31684 if (obj1) {
31685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31686 if (SWIG_arg_fail(2)) SWIG_fail;
31687 }
31688 {
31689 if (!wxPyCheckForApp()) SWIG_fail;
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31692
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 {
31697 resultobj = wxPyMake_wxObject(result, 0);
31698 }
31699 {
31700 if (temp1)
31701 delete arg1;
31702 }
31703 return resultobj;
31704 fail:
31705 {
31706 if (temp1)
31707 delete arg1;
31708 }
31709 return NULL;
31710 }
31711
31712
31713 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31714 PyObject *resultobj;
31715 wxString *arg1 = 0 ;
31716 wxWindow *arg2 = (wxWindow *) NULL ;
31717 wxWindow *result;
31718 bool temp1 = false ;
31719 PyObject * obj0 = 0 ;
31720 PyObject * obj1 = 0 ;
31721 char *kwnames[] = {
31722 (char *) "label",(char *) "parent", NULL
31723 };
31724
31725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31726 {
31727 arg1 = wxString_in_helper(obj0);
31728 if (arg1 == NULL) SWIG_fail;
31729 temp1 = true;
31730 }
31731 if (obj1) {
31732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31733 if (SWIG_arg_fail(2)) SWIG_fail;
31734 }
31735 {
31736 if (!wxPyCheckForApp()) SWIG_fail;
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31739
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 {
31744 resultobj = wxPyMake_wxObject(result, 0);
31745 }
31746 {
31747 if (temp1)
31748 delete arg1;
31749 }
31750 return resultobj;
31751 fail:
31752 {
31753 if (temp1)
31754 delete arg1;
31755 }
31756 return NULL;
31757 }
31758
31759
31760 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31761 PyObject *resultobj;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 unsigned long arg2 ;
31764 wxWindow *result;
31765 PyObject * obj0 = 0 ;
31766 PyObject * obj1 = 0 ;
31767 char *kwnames[] = {
31768 (char *) "parent",(char *) "_hWnd", NULL
31769 };
31770
31771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) 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 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31776 if (SWIG_arg_fail(2)) SWIG_fail;
31777 }
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31781
31782 wxPyEndAllowThreads(__tstate);
31783 if (PyErr_Occurred()) SWIG_fail;
31784 }
31785 {
31786 resultobj = wxPyMake_wxObject(result, 0);
31787 }
31788 return resultobj;
31789 fail:
31790 return NULL;
31791 }
31792
31793
31794 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31795 PyObject *resultobj;
31796 wxValidator *result;
31797 char *kwnames[] = {
31798 NULL
31799 };
31800
31801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = (wxValidator *)new wxValidator();
31805
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31817 PyObject *resultobj;
31818 wxValidator *arg1 = (wxValidator *) 0 ;
31819 wxValidator *result;
31820 PyObject * obj0 = 0 ;
31821 char *kwnames[] = {
31822 (char *) "self", NULL
31823 };
31824
31825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31827 if (SWIG_arg_fail(1)) SWIG_fail;
31828 {
31829 PyThreadState* __tstate = wxPyBeginAllowThreads();
31830 result = (wxValidator *)(arg1)->Clone();
31831
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 {
31836 resultobj = wxPyMake_wxObject(result, 0);
31837 }
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31845 PyObject *resultobj;
31846 wxValidator *arg1 = (wxValidator *) 0 ;
31847 wxWindow *arg2 = (wxWindow *) 0 ;
31848 bool result;
31849 PyObject * obj0 = 0 ;
31850 PyObject * obj1 = 0 ;
31851 char *kwnames[] = {
31852 (char *) "self",(char *) "parent", NULL
31853 };
31854
31855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31857 if (SWIG_arg_fail(1)) SWIG_fail;
31858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31859 if (SWIG_arg_fail(2)) SWIG_fail;
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 result = (bool)(arg1)->Validate(arg2);
31863
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 {
31868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31869 }
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31877 PyObject *resultobj;
31878 wxValidator *arg1 = (wxValidator *) 0 ;
31879 bool result;
31880 PyObject * obj0 = 0 ;
31881 char *kwnames[] = {
31882 (char *) "self", NULL
31883 };
31884
31885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31887 if (SWIG_arg_fail(1)) SWIG_fail;
31888 {
31889 PyThreadState* __tstate = wxPyBeginAllowThreads();
31890 result = (bool)(arg1)->TransferToWindow();
31891
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 {
31896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31897 }
31898 return resultobj;
31899 fail:
31900 return NULL;
31901 }
31902
31903
31904 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31905 PyObject *resultobj;
31906 wxValidator *arg1 = (wxValidator *) 0 ;
31907 bool result;
31908 PyObject * obj0 = 0 ;
31909 char *kwnames[] = {
31910 (char *) "self", NULL
31911 };
31912
31913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31915 if (SWIG_arg_fail(1)) SWIG_fail;
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 result = (bool)(arg1)->TransferFromWindow();
31919
31920 wxPyEndAllowThreads(__tstate);
31921 if (PyErr_Occurred()) SWIG_fail;
31922 }
31923 {
31924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31925 }
31926 return resultobj;
31927 fail:
31928 return NULL;
31929 }
31930
31931
31932 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31933 PyObject *resultobj;
31934 wxValidator *arg1 = (wxValidator *) 0 ;
31935 wxWindow *result;
31936 PyObject * obj0 = 0 ;
31937 char *kwnames[] = {
31938 (char *) "self", NULL
31939 };
31940
31941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31943 if (SWIG_arg_fail(1)) SWIG_fail;
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 result = (wxWindow *)(arg1)->GetWindow();
31947
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 {
31952 resultobj = wxPyMake_wxObject(result, 0);
31953 }
31954 return resultobj;
31955 fail:
31956 return NULL;
31957 }
31958
31959
31960 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31961 PyObject *resultobj;
31962 wxValidator *arg1 = (wxValidator *) 0 ;
31963 wxWindow *arg2 = (wxWindow *) 0 ;
31964 PyObject * obj0 = 0 ;
31965 PyObject * obj1 = 0 ;
31966 char *kwnames[] = {
31967 (char *) "self",(char *) "window", NULL
31968 };
31969
31970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31972 if (SWIG_arg_fail(1)) SWIG_fail;
31973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31974 if (SWIG_arg_fail(2)) SWIG_fail;
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 (arg1)->SetWindow(arg2);
31978
31979 wxPyEndAllowThreads(__tstate);
31980 if (PyErr_Occurred()) SWIG_fail;
31981 }
31982 Py_INCREF(Py_None); resultobj = Py_None;
31983 return resultobj;
31984 fail:
31985 return NULL;
31986 }
31987
31988
31989 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31990 PyObject *resultobj;
31991 bool result;
31992 char *kwnames[] = {
31993 NULL
31994 };
31995
31996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 result = (bool)wxValidator::IsSilent();
32000
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 {
32005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32006 }
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32014 PyObject *resultobj;
32015 int arg1 = (int) true ;
32016 PyObject * obj0 = 0 ;
32017 char *kwnames[] = {
32018 (char *) "doIt", NULL
32019 };
32020
32021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32022 if (obj0) {
32023 {
32024 arg1 = (int)(SWIG_As_int(obj0));
32025 if (SWIG_arg_fail(1)) SWIG_fail;
32026 }
32027 }
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 wxValidator::SetBellOnError(arg1);
32031
32032 wxPyEndAllowThreads(__tstate);
32033 if (PyErr_Occurred()) SWIG_fail;
32034 }
32035 Py_INCREF(Py_None); resultobj = Py_None;
32036 return resultobj;
32037 fail:
32038 return NULL;
32039 }
32040
32041
32042 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32043 PyObject *obj;
32044 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32045 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32046 Py_INCREF(obj);
32047 return Py_BuildValue((char *)"");
32048 }
32049 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj;
32051 wxPyValidator *result;
32052 char *kwnames[] = {
32053 NULL
32054 };
32055
32056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 result = (wxPyValidator *)new wxPyValidator();
32060
32061 wxPyEndAllowThreads(__tstate);
32062 if (PyErr_Occurred()) SWIG_fail;
32063 }
32064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32072 PyObject *resultobj;
32073 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32074 PyObject *arg2 = (PyObject *) 0 ;
32075 PyObject *arg3 = (PyObject *) 0 ;
32076 int arg4 = (int) true ;
32077 PyObject * obj0 = 0 ;
32078 PyObject * obj1 = 0 ;
32079 PyObject * obj2 = 0 ;
32080 PyObject * obj3 = 0 ;
32081 char *kwnames[] = {
32082 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32083 };
32084
32085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32087 if (SWIG_arg_fail(1)) SWIG_fail;
32088 arg2 = obj1;
32089 arg3 = obj2;
32090 if (obj3) {
32091 {
32092 arg4 = (int)(SWIG_As_int(obj3));
32093 if (SWIG_arg_fail(4)) SWIG_fail;
32094 }
32095 }
32096 {
32097 PyThreadState* __tstate = wxPyBeginAllowThreads();
32098 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32099
32100 wxPyEndAllowThreads(__tstate);
32101 if (PyErr_Occurred()) SWIG_fail;
32102 }
32103 Py_INCREF(Py_None); resultobj = Py_None;
32104 return resultobj;
32105 fail:
32106 return NULL;
32107 }
32108
32109
32110 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32111 PyObject *obj;
32112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32113 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32114 Py_INCREF(obj);
32115 return Py_BuildValue((char *)"");
32116 }
32117 static int _wrap_DefaultValidator_set(PyObject *) {
32118 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32119 return 1;
32120 }
32121
32122
32123 static PyObject *_wrap_DefaultValidator_get(void) {
32124 PyObject *pyobj;
32125
32126 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32127 return pyobj;
32128 }
32129
32130
32131 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32132 PyObject *resultobj;
32133 wxString const &arg1_defvalue = wxPyEmptyString ;
32134 wxString *arg1 = (wxString *) &arg1_defvalue ;
32135 long arg2 = (long) 0 ;
32136 wxMenu *result;
32137 bool temp1 = false ;
32138 PyObject * obj0 = 0 ;
32139 PyObject * obj1 = 0 ;
32140 char *kwnames[] = {
32141 (char *) "title",(char *) "style", NULL
32142 };
32143
32144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32145 if (obj0) {
32146 {
32147 arg1 = wxString_in_helper(obj0);
32148 if (arg1 == NULL) SWIG_fail;
32149 temp1 = true;
32150 }
32151 }
32152 if (obj1) {
32153 {
32154 arg2 = (long)(SWIG_As_long(obj1));
32155 if (SWIG_arg_fail(2)) SWIG_fail;
32156 }
32157 }
32158 {
32159 if (!wxPyCheckForApp()) SWIG_fail;
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32162
32163 wxPyEndAllowThreads(__tstate);
32164 if (PyErr_Occurred()) SWIG_fail;
32165 }
32166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32167 {
32168 if (temp1)
32169 delete arg1;
32170 }
32171 return resultobj;
32172 fail:
32173 {
32174 if (temp1)
32175 delete arg1;
32176 }
32177 return NULL;
32178 }
32179
32180
32181 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32182 PyObject *resultobj;
32183 wxMenu *arg1 = (wxMenu *) 0 ;
32184 int arg2 ;
32185 wxString *arg3 = 0 ;
32186 wxString const &arg4_defvalue = wxPyEmptyString ;
32187 wxString *arg4 = (wxString *) &arg4_defvalue ;
32188 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32189 wxMenuItem *result;
32190 bool temp3 = false ;
32191 bool temp4 = false ;
32192 PyObject * obj0 = 0 ;
32193 PyObject * obj1 = 0 ;
32194 PyObject * obj2 = 0 ;
32195 PyObject * obj3 = 0 ;
32196 PyObject * obj4 = 0 ;
32197 char *kwnames[] = {
32198 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32199 };
32200
32201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32203 if (SWIG_arg_fail(1)) SWIG_fail;
32204 {
32205 arg2 = (int)(SWIG_As_int(obj1));
32206 if (SWIG_arg_fail(2)) SWIG_fail;
32207 }
32208 {
32209 arg3 = wxString_in_helper(obj2);
32210 if (arg3 == NULL) SWIG_fail;
32211 temp3 = true;
32212 }
32213 if (obj3) {
32214 {
32215 arg4 = wxString_in_helper(obj3);
32216 if (arg4 == NULL) SWIG_fail;
32217 temp4 = true;
32218 }
32219 }
32220 if (obj4) {
32221 {
32222 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32223 if (SWIG_arg_fail(5)) SWIG_fail;
32224 }
32225 }
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32229
32230 wxPyEndAllowThreads(__tstate);
32231 if (PyErr_Occurred()) SWIG_fail;
32232 }
32233 {
32234 resultobj = wxPyMake_wxObject(result, 0);
32235 }
32236 {
32237 if (temp3)
32238 delete arg3;
32239 }
32240 {
32241 if (temp4)
32242 delete arg4;
32243 }
32244 return resultobj;
32245 fail:
32246 {
32247 if (temp3)
32248 delete arg3;
32249 }
32250 {
32251 if (temp4)
32252 delete arg4;
32253 }
32254 return NULL;
32255 }
32256
32257
32258 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj;
32260 wxMenu *arg1 = (wxMenu *) 0 ;
32261 wxMenuItem *result;
32262 PyObject * obj0 = 0 ;
32263 char *kwnames[] = {
32264 (char *) "self", NULL
32265 };
32266
32267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32269 if (SWIG_arg_fail(1)) SWIG_fail;
32270 {
32271 PyThreadState* __tstate = wxPyBeginAllowThreads();
32272 result = (wxMenuItem *)(arg1)->AppendSeparator();
32273
32274 wxPyEndAllowThreads(__tstate);
32275 if (PyErr_Occurred()) SWIG_fail;
32276 }
32277 {
32278 resultobj = wxPyMake_wxObject(result, 0);
32279 }
32280 return resultobj;
32281 fail:
32282 return NULL;
32283 }
32284
32285
32286 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32287 PyObject *resultobj;
32288 wxMenu *arg1 = (wxMenu *) 0 ;
32289 int arg2 ;
32290 wxString *arg3 = 0 ;
32291 wxString const &arg4_defvalue = wxPyEmptyString ;
32292 wxString *arg4 = (wxString *) &arg4_defvalue ;
32293 wxMenuItem *result;
32294 bool temp3 = false ;
32295 bool temp4 = false ;
32296 PyObject * obj0 = 0 ;
32297 PyObject * obj1 = 0 ;
32298 PyObject * obj2 = 0 ;
32299 PyObject * obj3 = 0 ;
32300 char *kwnames[] = {
32301 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32302 };
32303
32304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32306 if (SWIG_arg_fail(1)) SWIG_fail;
32307 {
32308 arg2 = (int)(SWIG_As_int(obj1));
32309 if (SWIG_arg_fail(2)) SWIG_fail;
32310 }
32311 {
32312 arg3 = wxString_in_helper(obj2);
32313 if (arg3 == NULL) SWIG_fail;
32314 temp3 = true;
32315 }
32316 if (obj3) {
32317 {
32318 arg4 = wxString_in_helper(obj3);
32319 if (arg4 == NULL) SWIG_fail;
32320 temp4 = true;
32321 }
32322 }
32323 {
32324 PyThreadState* __tstate = wxPyBeginAllowThreads();
32325 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32326
32327 wxPyEndAllowThreads(__tstate);
32328 if (PyErr_Occurred()) SWIG_fail;
32329 }
32330 {
32331 resultobj = wxPyMake_wxObject(result, 0);
32332 }
32333 {
32334 if (temp3)
32335 delete arg3;
32336 }
32337 {
32338 if (temp4)
32339 delete arg4;
32340 }
32341 return resultobj;
32342 fail:
32343 {
32344 if (temp3)
32345 delete arg3;
32346 }
32347 {
32348 if (temp4)
32349 delete arg4;
32350 }
32351 return NULL;
32352 }
32353
32354
32355 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj;
32357 wxMenu *arg1 = (wxMenu *) 0 ;
32358 int arg2 ;
32359 wxString *arg3 = 0 ;
32360 wxString const &arg4_defvalue = wxPyEmptyString ;
32361 wxString *arg4 = (wxString *) &arg4_defvalue ;
32362 wxMenuItem *result;
32363 bool temp3 = false ;
32364 bool temp4 = false ;
32365 PyObject * obj0 = 0 ;
32366 PyObject * obj1 = 0 ;
32367 PyObject * obj2 = 0 ;
32368 PyObject * obj3 = 0 ;
32369 char *kwnames[] = {
32370 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32371 };
32372
32373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32375 if (SWIG_arg_fail(1)) SWIG_fail;
32376 {
32377 arg2 = (int)(SWIG_As_int(obj1));
32378 if (SWIG_arg_fail(2)) SWIG_fail;
32379 }
32380 {
32381 arg3 = wxString_in_helper(obj2);
32382 if (arg3 == NULL) SWIG_fail;
32383 temp3 = true;
32384 }
32385 if (obj3) {
32386 {
32387 arg4 = wxString_in_helper(obj3);
32388 if (arg4 == NULL) SWIG_fail;
32389 temp4 = true;
32390 }
32391 }
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32395
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 {
32400 resultobj = wxPyMake_wxObject(result, 0);
32401 }
32402 {
32403 if (temp3)
32404 delete arg3;
32405 }
32406 {
32407 if (temp4)
32408 delete arg4;
32409 }
32410 return resultobj;
32411 fail:
32412 {
32413 if (temp3)
32414 delete arg3;
32415 }
32416 {
32417 if (temp4)
32418 delete arg4;
32419 }
32420 return NULL;
32421 }
32422
32423
32424 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32425 PyObject *resultobj;
32426 wxMenu *arg1 = (wxMenu *) 0 ;
32427 int arg2 ;
32428 wxString *arg3 = 0 ;
32429 wxMenu *arg4 = (wxMenu *) 0 ;
32430 wxString const &arg5_defvalue = wxPyEmptyString ;
32431 wxString *arg5 = (wxString *) &arg5_defvalue ;
32432 wxMenuItem *result;
32433 bool temp3 = false ;
32434 bool temp5 = false ;
32435 PyObject * obj0 = 0 ;
32436 PyObject * obj1 = 0 ;
32437 PyObject * obj2 = 0 ;
32438 PyObject * obj3 = 0 ;
32439 PyObject * obj4 = 0 ;
32440 char *kwnames[] = {
32441 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32442 };
32443
32444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32446 if (SWIG_arg_fail(1)) SWIG_fail;
32447 {
32448 arg2 = (int)(SWIG_As_int(obj1));
32449 if (SWIG_arg_fail(2)) SWIG_fail;
32450 }
32451 {
32452 arg3 = wxString_in_helper(obj2);
32453 if (arg3 == NULL) SWIG_fail;
32454 temp3 = true;
32455 }
32456 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32457 if (SWIG_arg_fail(4)) SWIG_fail;
32458 if (obj4) {
32459 {
32460 arg5 = wxString_in_helper(obj4);
32461 if (arg5 == NULL) SWIG_fail;
32462 temp5 = true;
32463 }
32464 }
32465 {
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32468
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 {
32473 resultobj = wxPyMake_wxObject(result, 0);
32474 }
32475 {
32476 if (temp3)
32477 delete arg3;
32478 }
32479 {
32480 if (temp5)
32481 delete arg5;
32482 }
32483 return resultobj;
32484 fail:
32485 {
32486 if (temp3)
32487 delete arg3;
32488 }
32489 {
32490 if (temp5)
32491 delete arg5;
32492 }
32493 return NULL;
32494 }
32495
32496
32497 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32498 PyObject *resultobj;
32499 wxMenu *arg1 = (wxMenu *) 0 ;
32500 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32501 wxMenuItem *result;
32502 PyObject * obj0 = 0 ;
32503 PyObject * obj1 = 0 ;
32504 char *kwnames[] = {
32505 (char *) "self",(char *) "item", NULL
32506 };
32507
32508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32510 if (SWIG_arg_fail(1)) SWIG_fail;
32511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32512 if (SWIG_arg_fail(2)) SWIG_fail;
32513 {
32514 PyThreadState* __tstate = wxPyBeginAllowThreads();
32515 result = (wxMenuItem *)(arg1)->Append(arg2);
32516
32517 wxPyEndAllowThreads(__tstate);
32518 if (PyErr_Occurred()) SWIG_fail;
32519 }
32520 {
32521 resultobj = wxPyMake_wxObject(result, 0);
32522 }
32523 return resultobj;
32524 fail:
32525 return NULL;
32526 }
32527
32528
32529 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32530 PyObject *resultobj;
32531 wxMenu *arg1 = (wxMenu *) 0 ;
32532 PyObject * obj0 = 0 ;
32533 char *kwnames[] = {
32534 (char *) "self", NULL
32535 };
32536
32537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32539 if (SWIG_arg_fail(1)) SWIG_fail;
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 (arg1)->Break();
32543
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 Py_INCREF(Py_None); resultobj = Py_None;
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32555 PyObject *resultobj;
32556 wxMenu *arg1 = (wxMenu *) 0 ;
32557 size_t arg2 ;
32558 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32559 wxMenuItem *result;
32560 PyObject * obj0 = 0 ;
32561 PyObject * obj1 = 0 ;
32562 PyObject * obj2 = 0 ;
32563 char *kwnames[] = {
32564 (char *) "self",(char *) "pos",(char *) "item", NULL
32565 };
32566
32567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32569 if (SWIG_arg_fail(1)) SWIG_fail;
32570 {
32571 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32572 if (SWIG_arg_fail(2)) SWIG_fail;
32573 }
32574 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32575 if (SWIG_arg_fail(3)) SWIG_fail;
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32579
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 resultobj = wxPyMake_wxObject(result, 0);
32585 }
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32593 PyObject *resultobj;
32594 wxMenu *arg1 = (wxMenu *) 0 ;
32595 size_t arg2 ;
32596 int arg3 ;
32597 wxString *arg4 = 0 ;
32598 wxString const &arg5_defvalue = wxPyEmptyString ;
32599 wxString *arg5 = (wxString *) &arg5_defvalue ;
32600 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32601 wxMenuItem *result;
32602 bool temp4 = false ;
32603 bool temp5 = false ;
32604 PyObject * obj0 = 0 ;
32605 PyObject * obj1 = 0 ;
32606 PyObject * obj2 = 0 ;
32607 PyObject * obj3 = 0 ;
32608 PyObject * obj4 = 0 ;
32609 PyObject * obj5 = 0 ;
32610 char *kwnames[] = {
32611 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32612 };
32613
32614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32616 if (SWIG_arg_fail(1)) SWIG_fail;
32617 {
32618 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32619 if (SWIG_arg_fail(2)) SWIG_fail;
32620 }
32621 {
32622 arg3 = (int)(SWIG_As_int(obj2));
32623 if (SWIG_arg_fail(3)) SWIG_fail;
32624 }
32625 {
32626 arg4 = wxString_in_helper(obj3);
32627 if (arg4 == NULL) SWIG_fail;
32628 temp4 = true;
32629 }
32630 if (obj4) {
32631 {
32632 arg5 = wxString_in_helper(obj4);
32633 if (arg5 == NULL) SWIG_fail;
32634 temp5 = true;
32635 }
32636 }
32637 if (obj5) {
32638 {
32639 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32640 if (SWIG_arg_fail(6)) SWIG_fail;
32641 }
32642 }
32643 {
32644 PyThreadState* __tstate = wxPyBeginAllowThreads();
32645 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32646
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 {
32651 resultobj = wxPyMake_wxObject(result, 0);
32652 }
32653 {
32654 if (temp4)
32655 delete arg4;
32656 }
32657 {
32658 if (temp5)
32659 delete arg5;
32660 }
32661 return resultobj;
32662 fail:
32663 {
32664 if (temp4)
32665 delete arg4;
32666 }
32667 {
32668 if (temp5)
32669 delete arg5;
32670 }
32671 return NULL;
32672 }
32673
32674
32675 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32676 PyObject *resultobj;
32677 wxMenu *arg1 = (wxMenu *) 0 ;
32678 size_t arg2 ;
32679 wxMenuItem *result;
32680 PyObject * obj0 = 0 ;
32681 PyObject * obj1 = 0 ;
32682 char *kwnames[] = {
32683 (char *) "self",(char *) "pos", NULL
32684 };
32685
32686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32688 if (SWIG_arg_fail(1)) SWIG_fail;
32689 {
32690 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32691 if (SWIG_arg_fail(2)) SWIG_fail;
32692 }
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32696
32697 wxPyEndAllowThreads(__tstate);
32698 if (PyErr_Occurred()) SWIG_fail;
32699 }
32700 {
32701 resultobj = wxPyMake_wxObject(result, 0);
32702 }
32703 return resultobj;
32704 fail:
32705 return NULL;
32706 }
32707
32708
32709 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32710 PyObject *resultobj;
32711 wxMenu *arg1 = (wxMenu *) 0 ;
32712 size_t arg2 ;
32713 int arg3 ;
32714 wxString *arg4 = 0 ;
32715 wxString const &arg5_defvalue = wxPyEmptyString ;
32716 wxString *arg5 = (wxString *) &arg5_defvalue ;
32717 wxMenuItem *result;
32718 bool temp4 = false ;
32719 bool temp5 = false ;
32720 PyObject * obj0 = 0 ;
32721 PyObject * obj1 = 0 ;
32722 PyObject * obj2 = 0 ;
32723 PyObject * obj3 = 0 ;
32724 PyObject * obj4 = 0 ;
32725 char *kwnames[] = {
32726 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32727 };
32728
32729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32731 if (SWIG_arg_fail(1)) SWIG_fail;
32732 {
32733 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32734 if (SWIG_arg_fail(2)) SWIG_fail;
32735 }
32736 {
32737 arg3 = (int)(SWIG_As_int(obj2));
32738 if (SWIG_arg_fail(3)) SWIG_fail;
32739 }
32740 {
32741 arg4 = wxString_in_helper(obj3);
32742 if (arg4 == NULL) SWIG_fail;
32743 temp4 = true;
32744 }
32745 if (obj4) {
32746 {
32747 arg5 = wxString_in_helper(obj4);
32748 if (arg5 == NULL) SWIG_fail;
32749 temp5 = true;
32750 }
32751 }
32752 {
32753 PyThreadState* __tstate = wxPyBeginAllowThreads();
32754 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32755
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 {
32760 resultobj = wxPyMake_wxObject(result, 0);
32761 }
32762 {
32763 if (temp4)
32764 delete arg4;
32765 }
32766 {
32767 if (temp5)
32768 delete arg5;
32769 }
32770 return resultobj;
32771 fail:
32772 {
32773 if (temp4)
32774 delete arg4;
32775 }
32776 {
32777 if (temp5)
32778 delete arg5;
32779 }
32780 return NULL;
32781 }
32782
32783
32784 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32785 PyObject *resultobj;
32786 wxMenu *arg1 = (wxMenu *) 0 ;
32787 size_t arg2 ;
32788 int arg3 ;
32789 wxString *arg4 = 0 ;
32790 wxString const &arg5_defvalue = wxPyEmptyString ;
32791 wxString *arg5 = (wxString *) &arg5_defvalue ;
32792 wxMenuItem *result;
32793 bool temp4 = false ;
32794 bool temp5 = false ;
32795 PyObject * obj0 = 0 ;
32796 PyObject * obj1 = 0 ;
32797 PyObject * obj2 = 0 ;
32798 PyObject * obj3 = 0 ;
32799 PyObject * obj4 = 0 ;
32800 char *kwnames[] = {
32801 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32802 };
32803
32804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32806 if (SWIG_arg_fail(1)) SWIG_fail;
32807 {
32808 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32809 if (SWIG_arg_fail(2)) SWIG_fail;
32810 }
32811 {
32812 arg3 = (int)(SWIG_As_int(obj2));
32813 if (SWIG_arg_fail(3)) SWIG_fail;
32814 }
32815 {
32816 arg4 = wxString_in_helper(obj3);
32817 if (arg4 == NULL) SWIG_fail;
32818 temp4 = true;
32819 }
32820 if (obj4) {
32821 {
32822 arg5 = wxString_in_helper(obj4);
32823 if (arg5 == NULL) SWIG_fail;
32824 temp5 = true;
32825 }
32826 }
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32830
32831 wxPyEndAllowThreads(__tstate);
32832 if (PyErr_Occurred()) SWIG_fail;
32833 }
32834 {
32835 resultobj = wxPyMake_wxObject(result, 0);
32836 }
32837 {
32838 if (temp4)
32839 delete arg4;
32840 }
32841 {
32842 if (temp5)
32843 delete arg5;
32844 }
32845 return resultobj;
32846 fail:
32847 {
32848 if (temp4)
32849 delete arg4;
32850 }
32851 {
32852 if (temp5)
32853 delete arg5;
32854 }
32855 return NULL;
32856 }
32857
32858
32859 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32860 PyObject *resultobj;
32861 wxMenu *arg1 = (wxMenu *) 0 ;
32862 size_t arg2 ;
32863 int arg3 ;
32864 wxString *arg4 = 0 ;
32865 wxMenu *arg5 = (wxMenu *) 0 ;
32866 wxString const &arg6_defvalue = wxPyEmptyString ;
32867 wxString *arg6 = (wxString *) &arg6_defvalue ;
32868 wxMenuItem *result;
32869 bool temp4 = false ;
32870 bool temp6 = false ;
32871 PyObject * obj0 = 0 ;
32872 PyObject * obj1 = 0 ;
32873 PyObject * obj2 = 0 ;
32874 PyObject * obj3 = 0 ;
32875 PyObject * obj4 = 0 ;
32876 PyObject * obj5 = 0 ;
32877 char *kwnames[] = {
32878 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32879 };
32880
32881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32883 if (SWIG_arg_fail(1)) SWIG_fail;
32884 {
32885 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32886 if (SWIG_arg_fail(2)) SWIG_fail;
32887 }
32888 {
32889 arg3 = (int)(SWIG_As_int(obj2));
32890 if (SWIG_arg_fail(3)) SWIG_fail;
32891 }
32892 {
32893 arg4 = wxString_in_helper(obj3);
32894 if (arg4 == NULL) SWIG_fail;
32895 temp4 = true;
32896 }
32897 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32898 if (SWIG_arg_fail(5)) SWIG_fail;
32899 if (obj5) {
32900 {
32901 arg6 = wxString_in_helper(obj5);
32902 if (arg6 == NULL) SWIG_fail;
32903 temp6 = true;
32904 }
32905 }
32906 {
32907 PyThreadState* __tstate = wxPyBeginAllowThreads();
32908 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32909
32910 wxPyEndAllowThreads(__tstate);
32911 if (PyErr_Occurred()) SWIG_fail;
32912 }
32913 {
32914 resultobj = wxPyMake_wxObject(result, 0);
32915 }
32916 {
32917 if (temp4)
32918 delete arg4;
32919 }
32920 {
32921 if (temp6)
32922 delete arg6;
32923 }
32924 return resultobj;
32925 fail:
32926 {
32927 if (temp4)
32928 delete arg4;
32929 }
32930 {
32931 if (temp6)
32932 delete arg6;
32933 }
32934 return NULL;
32935 }
32936
32937
32938 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32939 PyObject *resultobj;
32940 wxMenu *arg1 = (wxMenu *) 0 ;
32941 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32942 wxMenuItem *result;
32943 PyObject * obj0 = 0 ;
32944 PyObject * obj1 = 0 ;
32945 char *kwnames[] = {
32946 (char *) "self",(char *) "item", NULL
32947 };
32948
32949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32951 if (SWIG_arg_fail(1)) SWIG_fail;
32952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32953 if (SWIG_arg_fail(2)) SWIG_fail;
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32957
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 {
32962 resultobj = wxPyMake_wxObject(result, 0);
32963 }
32964 return resultobj;
32965 fail:
32966 return NULL;
32967 }
32968
32969
32970 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32971 PyObject *resultobj;
32972 wxMenu *arg1 = (wxMenu *) 0 ;
32973 int arg2 ;
32974 wxString *arg3 = 0 ;
32975 wxString const &arg4_defvalue = wxPyEmptyString ;
32976 wxString *arg4 = (wxString *) &arg4_defvalue ;
32977 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32978 wxMenuItem *result;
32979 bool temp3 = false ;
32980 bool temp4 = false ;
32981 PyObject * obj0 = 0 ;
32982 PyObject * obj1 = 0 ;
32983 PyObject * obj2 = 0 ;
32984 PyObject * obj3 = 0 ;
32985 PyObject * obj4 = 0 ;
32986 char *kwnames[] = {
32987 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32988 };
32989
32990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32992 if (SWIG_arg_fail(1)) SWIG_fail;
32993 {
32994 arg2 = (int)(SWIG_As_int(obj1));
32995 if (SWIG_arg_fail(2)) SWIG_fail;
32996 }
32997 {
32998 arg3 = wxString_in_helper(obj2);
32999 if (arg3 == NULL) SWIG_fail;
33000 temp3 = true;
33001 }
33002 if (obj3) {
33003 {
33004 arg4 = wxString_in_helper(obj3);
33005 if (arg4 == NULL) SWIG_fail;
33006 temp4 = true;
33007 }
33008 }
33009 if (obj4) {
33010 {
33011 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33012 if (SWIG_arg_fail(5)) SWIG_fail;
33013 }
33014 }
33015 {
33016 PyThreadState* __tstate = wxPyBeginAllowThreads();
33017 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33018
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 {
33023 resultobj = wxPyMake_wxObject(result, 0);
33024 }
33025 {
33026 if (temp3)
33027 delete arg3;
33028 }
33029 {
33030 if (temp4)
33031 delete arg4;
33032 }
33033 return resultobj;
33034 fail:
33035 {
33036 if (temp3)
33037 delete arg3;
33038 }
33039 {
33040 if (temp4)
33041 delete arg4;
33042 }
33043 return NULL;
33044 }
33045
33046
33047 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33048 PyObject *resultobj;
33049 wxMenu *arg1 = (wxMenu *) 0 ;
33050 wxMenuItem *result;
33051 PyObject * obj0 = 0 ;
33052 char *kwnames[] = {
33053 (char *) "self", NULL
33054 };
33055
33056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33058 if (SWIG_arg_fail(1)) SWIG_fail;
33059 {
33060 PyThreadState* __tstate = wxPyBeginAllowThreads();
33061 result = (wxMenuItem *)(arg1)->PrependSeparator();
33062
33063 wxPyEndAllowThreads(__tstate);
33064 if (PyErr_Occurred()) SWIG_fail;
33065 }
33066 {
33067 resultobj = wxPyMake_wxObject(result, 0);
33068 }
33069 return resultobj;
33070 fail:
33071 return NULL;
33072 }
33073
33074
33075 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33076 PyObject *resultobj;
33077 wxMenu *arg1 = (wxMenu *) 0 ;
33078 int arg2 ;
33079 wxString *arg3 = 0 ;
33080 wxString const &arg4_defvalue = wxPyEmptyString ;
33081 wxString *arg4 = (wxString *) &arg4_defvalue ;
33082 wxMenuItem *result;
33083 bool temp3 = false ;
33084 bool temp4 = false ;
33085 PyObject * obj0 = 0 ;
33086 PyObject * obj1 = 0 ;
33087 PyObject * obj2 = 0 ;
33088 PyObject * obj3 = 0 ;
33089 char *kwnames[] = {
33090 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33091 };
33092
33093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33095 if (SWIG_arg_fail(1)) SWIG_fail;
33096 {
33097 arg2 = (int)(SWIG_As_int(obj1));
33098 if (SWIG_arg_fail(2)) SWIG_fail;
33099 }
33100 {
33101 arg3 = wxString_in_helper(obj2);
33102 if (arg3 == NULL) SWIG_fail;
33103 temp3 = true;
33104 }
33105 if (obj3) {
33106 {
33107 arg4 = wxString_in_helper(obj3);
33108 if (arg4 == NULL) SWIG_fail;
33109 temp4 = true;
33110 }
33111 }
33112 {
33113 PyThreadState* __tstate = wxPyBeginAllowThreads();
33114 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33115
33116 wxPyEndAllowThreads(__tstate);
33117 if (PyErr_Occurred()) SWIG_fail;
33118 }
33119 {
33120 resultobj = wxPyMake_wxObject(result, 0);
33121 }
33122 {
33123 if (temp3)
33124 delete arg3;
33125 }
33126 {
33127 if (temp4)
33128 delete arg4;
33129 }
33130 return resultobj;
33131 fail:
33132 {
33133 if (temp3)
33134 delete arg3;
33135 }
33136 {
33137 if (temp4)
33138 delete arg4;
33139 }
33140 return NULL;
33141 }
33142
33143
33144 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33145 PyObject *resultobj;
33146 wxMenu *arg1 = (wxMenu *) 0 ;
33147 int arg2 ;
33148 wxString *arg3 = 0 ;
33149 wxString const &arg4_defvalue = wxPyEmptyString ;
33150 wxString *arg4 = (wxString *) &arg4_defvalue ;
33151 wxMenuItem *result;
33152 bool temp3 = false ;
33153 bool temp4 = false ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 PyObject * obj2 = 0 ;
33157 PyObject * obj3 = 0 ;
33158 char *kwnames[] = {
33159 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33160 };
33161
33162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33164 if (SWIG_arg_fail(1)) SWIG_fail;
33165 {
33166 arg2 = (int)(SWIG_As_int(obj1));
33167 if (SWIG_arg_fail(2)) SWIG_fail;
33168 }
33169 {
33170 arg3 = wxString_in_helper(obj2);
33171 if (arg3 == NULL) SWIG_fail;
33172 temp3 = true;
33173 }
33174 if (obj3) {
33175 {
33176 arg4 = wxString_in_helper(obj3);
33177 if (arg4 == NULL) SWIG_fail;
33178 temp4 = true;
33179 }
33180 }
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33184
33185 wxPyEndAllowThreads(__tstate);
33186 if (PyErr_Occurred()) SWIG_fail;
33187 }
33188 {
33189 resultobj = wxPyMake_wxObject(result, 0);
33190 }
33191 {
33192 if (temp3)
33193 delete arg3;
33194 }
33195 {
33196 if (temp4)
33197 delete arg4;
33198 }
33199 return resultobj;
33200 fail:
33201 {
33202 if (temp3)
33203 delete arg3;
33204 }
33205 {
33206 if (temp4)
33207 delete arg4;
33208 }
33209 return NULL;
33210 }
33211
33212
33213 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33214 PyObject *resultobj;
33215 wxMenu *arg1 = (wxMenu *) 0 ;
33216 int arg2 ;
33217 wxString *arg3 = 0 ;
33218 wxMenu *arg4 = (wxMenu *) 0 ;
33219 wxString const &arg5_defvalue = wxPyEmptyString ;
33220 wxString *arg5 = (wxString *) &arg5_defvalue ;
33221 wxMenuItem *result;
33222 bool temp3 = false ;
33223 bool temp5 = false ;
33224 PyObject * obj0 = 0 ;
33225 PyObject * obj1 = 0 ;
33226 PyObject * obj2 = 0 ;
33227 PyObject * obj3 = 0 ;
33228 PyObject * obj4 = 0 ;
33229 char *kwnames[] = {
33230 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33231 };
33232
33233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33235 if (SWIG_arg_fail(1)) SWIG_fail;
33236 {
33237 arg2 = (int)(SWIG_As_int(obj1));
33238 if (SWIG_arg_fail(2)) SWIG_fail;
33239 }
33240 {
33241 arg3 = wxString_in_helper(obj2);
33242 if (arg3 == NULL) SWIG_fail;
33243 temp3 = true;
33244 }
33245 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33246 if (SWIG_arg_fail(4)) SWIG_fail;
33247 if (obj4) {
33248 {
33249 arg5 = wxString_in_helper(obj4);
33250 if (arg5 == NULL) SWIG_fail;
33251 temp5 = true;
33252 }
33253 }
33254 {
33255 PyThreadState* __tstate = wxPyBeginAllowThreads();
33256 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33257
33258 wxPyEndAllowThreads(__tstate);
33259 if (PyErr_Occurred()) SWIG_fail;
33260 }
33261 {
33262 resultobj = wxPyMake_wxObject(result, 0);
33263 }
33264 {
33265 if (temp3)
33266 delete arg3;
33267 }
33268 {
33269 if (temp5)
33270 delete arg5;
33271 }
33272 return resultobj;
33273 fail:
33274 {
33275 if (temp3)
33276 delete arg3;
33277 }
33278 {
33279 if (temp5)
33280 delete arg5;
33281 }
33282 return NULL;
33283 }
33284
33285
33286 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33287 PyObject *resultobj;
33288 wxMenu *arg1 = (wxMenu *) 0 ;
33289 int arg2 ;
33290 wxMenuItem *result;
33291 PyObject * obj0 = 0 ;
33292 PyObject * obj1 = 0 ;
33293 char *kwnames[] = {
33294 (char *) "self",(char *) "id", NULL
33295 };
33296
33297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33299 if (SWIG_arg_fail(1)) SWIG_fail;
33300 {
33301 arg2 = (int)(SWIG_As_int(obj1));
33302 if (SWIG_arg_fail(2)) SWIG_fail;
33303 }
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = (wxMenuItem *)(arg1)->Remove(arg2);
33307
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = wxPyMake_wxObject(result, 0);
33313 }
33314 return resultobj;
33315 fail:
33316 return NULL;
33317 }
33318
33319
33320 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33321 PyObject *resultobj;
33322 wxMenu *arg1 = (wxMenu *) 0 ;
33323 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33324 wxMenuItem *result;
33325 PyObject * obj0 = 0 ;
33326 PyObject * obj1 = 0 ;
33327 char *kwnames[] = {
33328 (char *) "self",(char *) "item", NULL
33329 };
33330
33331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33333 if (SWIG_arg_fail(1)) SWIG_fail;
33334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33335 if (SWIG_arg_fail(2)) SWIG_fail;
33336 {
33337 PyThreadState* __tstate = wxPyBeginAllowThreads();
33338 result = (wxMenuItem *)(arg1)->Remove(arg2);
33339
33340 wxPyEndAllowThreads(__tstate);
33341 if (PyErr_Occurred()) SWIG_fail;
33342 }
33343 {
33344 resultobj = wxPyMake_wxObject(result, 0);
33345 }
33346 return resultobj;
33347 fail:
33348 return NULL;
33349 }
33350
33351
33352 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33353 PyObject *resultobj;
33354 wxMenu *arg1 = (wxMenu *) 0 ;
33355 int arg2 ;
33356 bool result;
33357 PyObject * obj0 = 0 ;
33358 PyObject * obj1 = 0 ;
33359 char *kwnames[] = {
33360 (char *) "self",(char *) "id", NULL
33361 };
33362
33363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33365 if (SWIG_arg_fail(1)) SWIG_fail;
33366 {
33367 arg2 = (int)(SWIG_As_int(obj1));
33368 if (SWIG_arg_fail(2)) SWIG_fail;
33369 }
33370 {
33371 PyThreadState* __tstate = wxPyBeginAllowThreads();
33372 result = (bool)(arg1)->Delete(arg2);
33373
33374 wxPyEndAllowThreads(__tstate);
33375 if (PyErr_Occurred()) SWIG_fail;
33376 }
33377 {
33378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33379 }
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33387 PyObject *resultobj;
33388 wxMenu *arg1 = (wxMenu *) 0 ;
33389 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33390 bool result;
33391 PyObject * obj0 = 0 ;
33392 PyObject * obj1 = 0 ;
33393 char *kwnames[] = {
33394 (char *) "self",(char *) "item", NULL
33395 };
33396
33397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33399 if (SWIG_arg_fail(1)) SWIG_fail;
33400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33401 if (SWIG_arg_fail(2)) SWIG_fail;
33402 {
33403 PyThreadState* __tstate = wxPyBeginAllowThreads();
33404 result = (bool)(arg1)->Delete(arg2);
33405
33406 wxPyEndAllowThreads(__tstate);
33407 if (PyErr_Occurred()) SWIG_fail;
33408 }
33409 {
33410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33411 }
33412 return resultobj;
33413 fail:
33414 return NULL;
33415 }
33416
33417
33418 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33419 PyObject *resultobj;
33420 wxMenu *arg1 = (wxMenu *) 0 ;
33421 PyObject * obj0 = 0 ;
33422 char *kwnames[] = {
33423 (char *) "self", NULL
33424 };
33425
33426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(1)) SWIG_fail;
33429 {
33430 PyThreadState* __tstate = wxPyBeginAllowThreads();
33431 wxMenu_Destroy(arg1);
33432
33433 wxPyEndAllowThreads(__tstate);
33434 if (PyErr_Occurred()) SWIG_fail;
33435 }
33436 Py_INCREF(Py_None); resultobj = Py_None;
33437 return resultobj;
33438 fail:
33439 return NULL;
33440 }
33441
33442
33443 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33444 PyObject *resultobj;
33445 wxMenu *arg1 = (wxMenu *) 0 ;
33446 int arg2 ;
33447 bool result;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 char *kwnames[] = {
33451 (char *) "self",(char *) "id", NULL
33452 };
33453
33454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33456 if (SWIG_arg_fail(1)) SWIG_fail;
33457 {
33458 arg2 = (int)(SWIG_As_int(obj1));
33459 if (SWIG_arg_fail(2)) SWIG_fail;
33460 }
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (bool)(arg1)->Destroy(arg2);
33464
33465 wxPyEndAllowThreads(__tstate);
33466 if (PyErr_Occurred()) SWIG_fail;
33467 }
33468 {
33469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33470 }
33471 return resultobj;
33472 fail:
33473 return NULL;
33474 }
33475
33476
33477 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33478 PyObject *resultobj;
33479 wxMenu *arg1 = (wxMenu *) 0 ;
33480 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33481 bool result;
33482 PyObject * obj0 = 0 ;
33483 PyObject * obj1 = 0 ;
33484 char *kwnames[] = {
33485 (char *) "self",(char *) "item", NULL
33486 };
33487
33488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33490 if (SWIG_arg_fail(1)) SWIG_fail;
33491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33492 if (SWIG_arg_fail(2)) SWIG_fail;
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 result = (bool)(arg1)->Destroy(arg2);
33496
33497 wxPyEndAllowThreads(__tstate);
33498 if (PyErr_Occurred()) SWIG_fail;
33499 }
33500 {
33501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33502 }
33503 return resultobj;
33504 fail:
33505 return NULL;
33506 }
33507
33508
33509 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33510 PyObject *resultobj;
33511 wxMenu *arg1 = (wxMenu *) 0 ;
33512 size_t result;
33513 PyObject * obj0 = 0 ;
33514 char *kwnames[] = {
33515 (char *) "self", NULL
33516 };
33517
33518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33520 if (SWIG_arg_fail(1)) SWIG_fail;
33521 {
33522 PyThreadState* __tstate = wxPyBeginAllowThreads();
33523 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33524
33525 wxPyEndAllowThreads(__tstate);
33526 if (PyErr_Occurred()) SWIG_fail;
33527 }
33528 {
33529 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33530 }
33531 return resultobj;
33532 fail:
33533 return NULL;
33534 }
33535
33536
33537 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33538 PyObject *resultobj;
33539 wxMenu *arg1 = (wxMenu *) 0 ;
33540 PyObject *result;
33541 PyObject * obj0 = 0 ;
33542 char *kwnames[] = {
33543 (char *) "self", NULL
33544 };
33545
33546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33548 if (SWIG_arg_fail(1)) SWIG_fail;
33549 {
33550 PyThreadState* __tstate = wxPyBeginAllowThreads();
33551 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33552
33553 wxPyEndAllowThreads(__tstate);
33554 if (PyErr_Occurred()) SWIG_fail;
33555 }
33556 resultobj = result;
33557 return resultobj;
33558 fail:
33559 return NULL;
33560 }
33561
33562
33563 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33564 PyObject *resultobj;
33565 wxMenu *arg1 = (wxMenu *) 0 ;
33566 wxString *arg2 = 0 ;
33567 int result;
33568 bool temp2 = false ;
33569 PyObject * obj0 = 0 ;
33570 PyObject * obj1 = 0 ;
33571 char *kwnames[] = {
33572 (char *) "self",(char *) "item", NULL
33573 };
33574
33575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33577 if (SWIG_arg_fail(1)) SWIG_fail;
33578 {
33579 arg2 = wxString_in_helper(obj1);
33580 if (arg2 == NULL) SWIG_fail;
33581 temp2 = true;
33582 }
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33586
33587 wxPyEndAllowThreads(__tstate);
33588 if (PyErr_Occurred()) SWIG_fail;
33589 }
33590 {
33591 resultobj = SWIG_From_int((int)(result));
33592 }
33593 {
33594 if (temp2)
33595 delete arg2;
33596 }
33597 return resultobj;
33598 fail:
33599 {
33600 if (temp2)
33601 delete arg2;
33602 }
33603 return NULL;
33604 }
33605
33606
33607 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33608 PyObject *resultobj;
33609 wxMenu *arg1 = (wxMenu *) 0 ;
33610 int arg2 ;
33611 wxMenuItem *result;
33612 PyObject * obj0 = 0 ;
33613 PyObject * obj1 = 0 ;
33614 char *kwnames[] = {
33615 (char *) "self",(char *) "id", NULL
33616 };
33617
33618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33620 if (SWIG_arg_fail(1)) SWIG_fail;
33621 {
33622 arg2 = (int)(SWIG_As_int(obj1));
33623 if (SWIG_arg_fail(2)) SWIG_fail;
33624 }
33625 {
33626 PyThreadState* __tstate = wxPyBeginAllowThreads();
33627 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33628
33629 wxPyEndAllowThreads(__tstate);
33630 if (PyErr_Occurred()) SWIG_fail;
33631 }
33632 {
33633 resultobj = wxPyMake_wxObject(result, 0);
33634 }
33635 return resultobj;
33636 fail:
33637 return NULL;
33638 }
33639
33640
33641 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33642 PyObject *resultobj;
33643 wxMenu *arg1 = (wxMenu *) 0 ;
33644 size_t arg2 ;
33645 wxMenuItem *result;
33646 PyObject * obj0 = 0 ;
33647 PyObject * obj1 = 0 ;
33648 char *kwnames[] = {
33649 (char *) "self",(char *) "position", NULL
33650 };
33651
33652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33654 if (SWIG_arg_fail(1)) SWIG_fail;
33655 {
33656 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33657 if (SWIG_arg_fail(2)) SWIG_fail;
33658 }
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33662
33663 wxPyEndAllowThreads(__tstate);
33664 if (PyErr_Occurred()) SWIG_fail;
33665 }
33666 {
33667 resultobj = wxPyMake_wxObject(result, 0);
33668 }
33669 return resultobj;
33670 fail:
33671 return NULL;
33672 }
33673
33674
33675 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33676 PyObject *resultobj;
33677 wxMenu *arg1 = (wxMenu *) 0 ;
33678 int arg2 ;
33679 bool arg3 ;
33680 PyObject * obj0 = 0 ;
33681 PyObject * obj1 = 0 ;
33682 PyObject * obj2 = 0 ;
33683 char *kwnames[] = {
33684 (char *) "self",(char *) "id",(char *) "enable", NULL
33685 };
33686
33687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33689 if (SWIG_arg_fail(1)) SWIG_fail;
33690 {
33691 arg2 = (int)(SWIG_As_int(obj1));
33692 if (SWIG_arg_fail(2)) SWIG_fail;
33693 }
33694 {
33695 arg3 = (bool)(SWIG_As_bool(obj2));
33696 if (SWIG_arg_fail(3)) SWIG_fail;
33697 }
33698 {
33699 PyThreadState* __tstate = wxPyBeginAllowThreads();
33700 (arg1)->Enable(arg2,arg3);
33701
33702 wxPyEndAllowThreads(__tstate);
33703 if (PyErr_Occurred()) SWIG_fail;
33704 }
33705 Py_INCREF(Py_None); resultobj = Py_None;
33706 return resultobj;
33707 fail:
33708 return NULL;
33709 }
33710
33711
33712 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33713 PyObject *resultobj;
33714 wxMenu *arg1 = (wxMenu *) 0 ;
33715 int arg2 ;
33716 bool result;
33717 PyObject * obj0 = 0 ;
33718 PyObject * obj1 = 0 ;
33719 char *kwnames[] = {
33720 (char *) "self",(char *) "id", NULL
33721 };
33722
33723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33725 if (SWIG_arg_fail(1)) SWIG_fail;
33726 {
33727 arg2 = (int)(SWIG_As_int(obj1));
33728 if (SWIG_arg_fail(2)) SWIG_fail;
33729 }
33730 {
33731 PyThreadState* __tstate = wxPyBeginAllowThreads();
33732 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33733
33734 wxPyEndAllowThreads(__tstate);
33735 if (PyErr_Occurred()) SWIG_fail;
33736 }
33737 {
33738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33739 }
33740 return resultobj;
33741 fail:
33742 return NULL;
33743 }
33744
33745
33746 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33747 PyObject *resultobj;
33748 wxMenu *arg1 = (wxMenu *) 0 ;
33749 int arg2 ;
33750 bool arg3 ;
33751 PyObject * obj0 = 0 ;
33752 PyObject * obj1 = 0 ;
33753 PyObject * obj2 = 0 ;
33754 char *kwnames[] = {
33755 (char *) "self",(char *) "id",(char *) "check", NULL
33756 };
33757
33758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33760 if (SWIG_arg_fail(1)) SWIG_fail;
33761 {
33762 arg2 = (int)(SWIG_As_int(obj1));
33763 if (SWIG_arg_fail(2)) SWIG_fail;
33764 }
33765 {
33766 arg3 = (bool)(SWIG_As_bool(obj2));
33767 if (SWIG_arg_fail(3)) SWIG_fail;
33768 }
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 (arg1)->Check(arg2,arg3);
33772
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 Py_INCREF(Py_None); resultobj = Py_None;
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj;
33785 wxMenu *arg1 = (wxMenu *) 0 ;
33786 int arg2 ;
33787 bool result;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 char *kwnames[] = {
33791 (char *) "self",(char *) "id", NULL
33792 };
33793
33794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33796 if (SWIG_arg_fail(1)) SWIG_fail;
33797 {
33798 arg2 = (int)(SWIG_As_int(obj1));
33799 if (SWIG_arg_fail(2)) SWIG_fail;
33800 }
33801 {
33802 PyThreadState* __tstate = wxPyBeginAllowThreads();
33803 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33804
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 {
33809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33810 }
33811 return resultobj;
33812 fail:
33813 return NULL;
33814 }
33815
33816
33817 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33818 PyObject *resultobj;
33819 wxMenu *arg1 = (wxMenu *) 0 ;
33820 int arg2 ;
33821 wxString *arg3 = 0 ;
33822 bool temp3 = false ;
33823 PyObject * obj0 = 0 ;
33824 PyObject * obj1 = 0 ;
33825 PyObject * obj2 = 0 ;
33826 char *kwnames[] = {
33827 (char *) "self",(char *) "id",(char *) "label", NULL
33828 };
33829
33830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33832 if (SWIG_arg_fail(1)) SWIG_fail;
33833 {
33834 arg2 = (int)(SWIG_As_int(obj1));
33835 if (SWIG_arg_fail(2)) SWIG_fail;
33836 }
33837 {
33838 arg3 = wxString_in_helper(obj2);
33839 if (arg3 == NULL) SWIG_fail;
33840 temp3 = true;
33841 }
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33845
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 Py_INCREF(Py_None); resultobj = Py_None;
33850 {
33851 if (temp3)
33852 delete arg3;
33853 }
33854 return resultobj;
33855 fail:
33856 {
33857 if (temp3)
33858 delete arg3;
33859 }
33860 return NULL;
33861 }
33862
33863
33864 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33865 PyObject *resultobj;
33866 wxMenu *arg1 = (wxMenu *) 0 ;
33867 int arg2 ;
33868 wxString result;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char *kwnames[] = {
33872 (char *) "self",(char *) "id", NULL
33873 };
33874
33875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33877 if (SWIG_arg_fail(1)) SWIG_fail;
33878 {
33879 arg2 = (int)(SWIG_As_int(obj1));
33880 if (SWIG_arg_fail(2)) SWIG_fail;
33881 }
33882 {
33883 PyThreadState* __tstate = wxPyBeginAllowThreads();
33884 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33885
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 {
33890 #if wxUSE_UNICODE
33891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33892 #else
33893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33894 #endif
33895 }
33896 return resultobj;
33897 fail:
33898 return NULL;
33899 }
33900
33901
33902 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33903 PyObject *resultobj;
33904 wxMenu *arg1 = (wxMenu *) 0 ;
33905 int arg2 ;
33906 wxString *arg3 = 0 ;
33907 bool temp3 = false ;
33908 PyObject * obj0 = 0 ;
33909 PyObject * obj1 = 0 ;
33910 PyObject * obj2 = 0 ;
33911 char *kwnames[] = {
33912 (char *) "self",(char *) "id",(char *) "helpString", NULL
33913 };
33914
33915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33917 if (SWIG_arg_fail(1)) SWIG_fail;
33918 {
33919 arg2 = (int)(SWIG_As_int(obj1));
33920 if (SWIG_arg_fail(2)) SWIG_fail;
33921 }
33922 {
33923 arg3 = wxString_in_helper(obj2);
33924 if (arg3 == NULL) SWIG_fail;
33925 temp3 = true;
33926 }
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33930
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 Py_INCREF(Py_None); resultobj = Py_None;
33935 {
33936 if (temp3)
33937 delete arg3;
33938 }
33939 return resultobj;
33940 fail:
33941 {
33942 if (temp3)
33943 delete arg3;
33944 }
33945 return NULL;
33946 }
33947
33948
33949 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj;
33951 wxMenu *arg1 = (wxMenu *) 0 ;
33952 int arg2 ;
33953 wxString result;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 char *kwnames[] = {
33957 (char *) "self",(char *) "id", NULL
33958 };
33959
33960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33962 if (SWIG_arg_fail(1)) SWIG_fail;
33963 {
33964 arg2 = (int)(SWIG_As_int(obj1));
33965 if (SWIG_arg_fail(2)) SWIG_fail;
33966 }
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33970
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 {
33975 #if wxUSE_UNICODE
33976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33977 #else
33978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33979 #endif
33980 }
33981 return resultobj;
33982 fail:
33983 return NULL;
33984 }
33985
33986
33987 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33988 PyObject *resultobj;
33989 wxMenu *arg1 = (wxMenu *) 0 ;
33990 wxString *arg2 = 0 ;
33991 bool temp2 = false ;
33992 PyObject * obj0 = 0 ;
33993 PyObject * obj1 = 0 ;
33994 char *kwnames[] = {
33995 (char *) "self",(char *) "title", NULL
33996 };
33997
33998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34000 if (SWIG_arg_fail(1)) SWIG_fail;
34001 {
34002 arg2 = wxString_in_helper(obj1);
34003 if (arg2 == NULL) SWIG_fail;
34004 temp2 = true;
34005 }
34006 {
34007 PyThreadState* __tstate = wxPyBeginAllowThreads();
34008 (arg1)->SetTitle((wxString const &)*arg2);
34009
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 Py_INCREF(Py_None); resultobj = Py_None;
34014 {
34015 if (temp2)
34016 delete arg2;
34017 }
34018 return resultobj;
34019 fail:
34020 {
34021 if (temp2)
34022 delete arg2;
34023 }
34024 return NULL;
34025 }
34026
34027
34028 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34029 PyObject *resultobj;
34030 wxMenu *arg1 = (wxMenu *) 0 ;
34031 wxString result;
34032 PyObject * obj0 = 0 ;
34033 char *kwnames[] = {
34034 (char *) "self", NULL
34035 };
34036
34037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34039 if (SWIG_arg_fail(1)) SWIG_fail;
34040 {
34041 PyThreadState* __tstate = wxPyBeginAllowThreads();
34042 result = ((wxMenu const *)arg1)->GetTitle();
34043
34044 wxPyEndAllowThreads(__tstate);
34045 if (PyErr_Occurred()) SWIG_fail;
34046 }
34047 {
34048 #if wxUSE_UNICODE
34049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34050 #else
34051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34052 #endif
34053 }
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34061 PyObject *resultobj;
34062 wxMenu *arg1 = (wxMenu *) 0 ;
34063 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34064 PyObject * obj0 = 0 ;
34065 PyObject * obj1 = 0 ;
34066 char *kwnames[] = {
34067 (char *) "self",(char *) "handler", NULL
34068 };
34069
34070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34072 if (SWIG_arg_fail(1)) SWIG_fail;
34073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34074 if (SWIG_arg_fail(2)) SWIG_fail;
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 (arg1)->SetEventHandler(arg2);
34078
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 Py_INCREF(Py_None); resultobj = Py_None;
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 wxEvtHandler *result;
34093 PyObject * obj0 = 0 ;
34094 char *kwnames[] = {
34095 (char *) "self", NULL
34096 };
34097
34098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34100 if (SWIG_arg_fail(1)) SWIG_fail;
34101 {
34102 PyThreadState* __tstate = wxPyBeginAllowThreads();
34103 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34104
34105 wxPyEndAllowThreads(__tstate);
34106 if (PyErr_Occurred()) SWIG_fail;
34107 }
34108 {
34109 resultobj = wxPyMake_wxObject(result, 0);
34110 }
34111 return resultobj;
34112 fail:
34113 return NULL;
34114 }
34115
34116
34117 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34118 PyObject *resultobj;
34119 wxMenu *arg1 = (wxMenu *) 0 ;
34120 wxWindow *arg2 = (wxWindow *) 0 ;
34121 PyObject * obj0 = 0 ;
34122 PyObject * obj1 = 0 ;
34123 char *kwnames[] = {
34124 (char *) "self",(char *) "win", NULL
34125 };
34126
34127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34129 if (SWIG_arg_fail(1)) SWIG_fail;
34130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34131 if (SWIG_arg_fail(2)) SWIG_fail;
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 (arg1)->SetInvokingWindow(arg2);
34135
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 Py_INCREF(Py_None); resultobj = Py_None;
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34147 PyObject *resultobj;
34148 wxMenu *arg1 = (wxMenu *) 0 ;
34149 wxWindow *result;
34150 PyObject * obj0 = 0 ;
34151 char *kwnames[] = {
34152 (char *) "self", NULL
34153 };
34154
34155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34157 if (SWIG_arg_fail(1)) SWIG_fail;
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34161
34162 wxPyEndAllowThreads(__tstate);
34163 if (PyErr_Occurred()) SWIG_fail;
34164 }
34165 {
34166 resultobj = wxPyMake_wxObject(result, 0);
34167 }
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34175 PyObject *resultobj;
34176 wxMenu *arg1 = (wxMenu *) 0 ;
34177 long result;
34178 PyObject * obj0 = 0 ;
34179 char *kwnames[] = {
34180 (char *) "self", NULL
34181 };
34182
34183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34185 if (SWIG_arg_fail(1)) SWIG_fail;
34186 {
34187 PyThreadState* __tstate = wxPyBeginAllowThreads();
34188 result = (long)((wxMenu const *)arg1)->GetStyle();
34189
34190 wxPyEndAllowThreads(__tstate);
34191 if (PyErr_Occurred()) SWIG_fail;
34192 }
34193 {
34194 resultobj = SWIG_From_long((long)(result));
34195 }
34196 return resultobj;
34197 fail:
34198 return NULL;
34199 }
34200
34201
34202 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34203 PyObject *resultobj;
34204 wxMenu *arg1 = (wxMenu *) 0 ;
34205 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34206 PyObject * obj0 = 0 ;
34207 PyObject * obj1 = 0 ;
34208 char *kwnames[] = {
34209 (char *) "self",(char *) "source", NULL
34210 };
34211
34212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34214 if (SWIG_arg_fail(1)) SWIG_fail;
34215 if (obj1) {
34216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34217 if (SWIG_arg_fail(2)) SWIG_fail;
34218 }
34219 {
34220 PyThreadState* __tstate = wxPyBeginAllowThreads();
34221 (arg1)->UpdateUI(arg2);
34222
34223 wxPyEndAllowThreads(__tstate);
34224 if (PyErr_Occurred()) SWIG_fail;
34225 }
34226 Py_INCREF(Py_None); resultobj = Py_None;
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34234 PyObject *resultobj;
34235 wxMenu *arg1 = (wxMenu *) 0 ;
34236 wxMenuBar *result;
34237 PyObject * obj0 = 0 ;
34238 char *kwnames[] = {
34239 (char *) "self", NULL
34240 };
34241
34242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34244 if (SWIG_arg_fail(1)) SWIG_fail;
34245 {
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34248
34249 wxPyEndAllowThreads(__tstate);
34250 if (PyErr_Occurred()) SWIG_fail;
34251 }
34252 {
34253 resultobj = wxPyMake_wxObject(result, 0);
34254 }
34255 return resultobj;
34256 fail:
34257 return NULL;
34258 }
34259
34260
34261 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34262 PyObject *resultobj;
34263 wxMenu *arg1 = (wxMenu *) 0 ;
34264 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34265 PyObject * obj0 = 0 ;
34266 PyObject * obj1 = 0 ;
34267 char *kwnames[] = {
34268 (char *) "self",(char *) "menubar", NULL
34269 };
34270
34271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34273 if (SWIG_arg_fail(1)) SWIG_fail;
34274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34275 if (SWIG_arg_fail(2)) SWIG_fail;
34276 {
34277 PyThreadState* __tstate = wxPyBeginAllowThreads();
34278 (arg1)->Attach(arg2);
34279
34280 wxPyEndAllowThreads(__tstate);
34281 if (PyErr_Occurred()) SWIG_fail;
34282 }
34283 Py_INCREF(Py_None); resultobj = Py_None;
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34291 PyObject *resultobj;
34292 wxMenu *arg1 = (wxMenu *) 0 ;
34293 PyObject * obj0 = 0 ;
34294 char *kwnames[] = {
34295 (char *) "self", NULL
34296 };
34297
34298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34300 if (SWIG_arg_fail(1)) SWIG_fail;
34301 {
34302 PyThreadState* __tstate = wxPyBeginAllowThreads();
34303 (arg1)->Detach();
34304
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 Py_INCREF(Py_None); resultobj = Py_None;
34309 return resultobj;
34310 fail:
34311 return NULL;
34312 }
34313
34314
34315 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34316 PyObject *resultobj;
34317 wxMenu *arg1 = (wxMenu *) 0 ;
34318 bool result;
34319 PyObject * obj0 = 0 ;
34320 char *kwnames[] = {
34321 (char *) "self", NULL
34322 };
34323
34324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34326 if (SWIG_arg_fail(1)) SWIG_fail;
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 result = (bool)((wxMenu const *)arg1)->IsAttached();
34330
34331 wxPyEndAllowThreads(__tstate);
34332 if (PyErr_Occurred()) SWIG_fail;
34333 }
34334 {
34335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34336 }
34337 return resultobj;
34338 fail:
34339 return NULL;
34340 }
34341
34342
34343 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34344 PyObject *resultobj;
34345 wxMenu *arg1 = (wxMenu *) 0 ;
34346 wxMenu *arg2 = (wxMenu *) 0 ;
34347 PyObject * obj0 = 0 ;
34348 PyObject * obj1 = 0 ;
34349 char *kwnames[] = {
34350 (char *) "self",(char *) "parent", NULL
34351 };
34352
34353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34355 if (SWIG_arg_fail(1)) SWIG_fail;
34356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34357 if (SWIG_arg_fail(2)) SWIG_fail;
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 (arg1)->SetParent(arg2);
34361
34362 wxPyEndAllowThreads(__tstate);
34363 if (PyErr_Occurred()) SWIG_fail;
34364 }
34365 Py_INCREF(Py_None); resultobj = Py_None;
34366 return resultobj;
34367 fail:
34368 return NULL;
34369 }
34370
34371
34372 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34373 PyObject *resultobj;
34374 wxMenu *arg1 = (wxMenu *) 0 ;
34375 wxMenu *result;
34376 PyObject * obj0 = 0 ;
34377 char *kwnames[] = {
34378 (char *) "self", NULL
34379 };
34380
34381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34383 if (SWIG_arg_fail(1)) SWIG_fail;
34384 {
34385 PyThreadState* __tstate = wxPyBeginAllowThreads();
34386 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34387
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 {
34392 resultobj = wxPyMake_wxObject(result, 0);
34393 }
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34401 PyObject *obj;
34402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34403 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34404 Py_INCREF(obj);
34405 return Py_BuildValue((char *)"");
34406 }
34407 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34408 PyObject *resultobj;
34409 long arg1 = (long) 0 ;
34410 wxMenuBar *result;
34411 PyObject * obj0 = 0 ;
34412 char *kwnames[] = {
34413 (char *) "style", NULL
34414 };
34415
34416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34417 if (obj0) {
34418 {
34419 arg1 = (long)(SWIG_As_long(obj0));
34420 if (SWIG_arg_fail(1)) SWIG_fail;
34421 }
34422 }
34423 {
34424 if (!wxPyCheckForApp()) SWIG_fail;
34425 PyThreadState* __tstate = wxPyBeginAllowThreads();
34426 result = (wxMenuBar *)new wxMenuBar(arg1);
34427
34428 wxPyEndAllowThreads(__tstate);
34429 if (PyErr_Occurred()) SWIG_fail;
34430 }
34431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34432 return resultobj;
34433 fail:
34434 return NULL;
34435 }
34436
34437
34438 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34439 PyObject *resultobj;
34440 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34441 wxMenu *arg2 = (wxMenu *) 0 ;
34442 wxString *arg3 = 0 ;
34443 bool result;
34444 bool temp3 = false ;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 PyObject * obj2 = 0 ;
34448 char *kwnames[] = {
34449 (char *) "self",(char *) "menu",(char *) "title", NULL
34450 };
34451
34452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34454 if (SWIG_arg_fail(1)) SWIG_fail;
34455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34456 if (SWIG_arg_fail(2)) SWIG_fail;
34457 {
34458 arg3 = wxString_in_helper(obj2);
34459 if (arg3 == NULL) SWIG_fail;
34460 temp3 = true;
34461 }
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34465
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 {
34470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34471 }
34472 {
34473 if (temp3)
34474 delete arg3;
34475 }
34476 return resultobj;
34477 fail:
34478 {
34479 if (temp3)
34480 delete arg3;
34481 }
34482 return NULL;
34483 }
34484
34485
34486 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34487 PyObject *resultobj;
34488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34489 size_t arg2 ;
34490 wxMenu *arg3 = (wxMenu *) 0 ;
34491 wxString *arg4 = 0 ;
34492 bool result;
34493 bool temp4 = false ;
34494 PyObject * obj0 = 0 ;
34495 PyObject * obj1 = 0 ;
34496 PyObject * obj2 = 0 ;
34497 PyObject * obj3 = 0 ;
34498 char *kwnames[] = {
34499 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34500 };
34501
34502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34504 if (SWIG_arg_fail(1)) SWIG_fail;
34505 {
34506 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34507 if (SWIG_arg_fail(2)) SWIG_fail;
34508 }
34509 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34510 if (SWIG_arg_fail(3)) SWIG_fail;
34511 {
34512 arg4 = wxString_in_helper(obj3);
34513 if (arg4 == NULL) SWIG_fail;
34514 temp4 = true;
34515 }
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34519
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 {
34524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34525 }
34526 {
34527 if (temp4)
34528 delete arg4;
34529 }
34530 return resultobj;
34531 fail:
34532 {
34533 if (temp4)
34534 delete arg4;
34535 }
34536 return NULL;
34537 }
34538
34539
34540 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34541 PyObject *resultobj;
34542 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34543 size_t result;
34544 PyObject * obj0 = 0 ;
34545 char *kwnames[] = {
34546 (char *) "self", NULL
34547 };
34548
34549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34551 if (SWIG_arg_fail(1)) SWIG_fail;
34552 {
34553 PyThreadState* __tstate = wxPyBeginAllowThreads();
34554 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34555
34556 wxPyEndAllowThreads(__tstate);
34557 if (PyErr_Occurred()) SWIG_fail;
34558 }
34559 {
34560 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34561 }
34562 return resultobj;
34563 fail:
34564 return NULL;
34565 }
34566
34567
34568 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34569 PyObject *resultobj;
34570 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34571 size_t arg2 ;
34572 wxMenu *result;
34573 PyObject * obj0 = 0 ;
34574 PyObject * obj1 = 0 ;
34575 char *kwnames[] = {
34576 (char *) "self",(char *) "pos", NULL
34577 };
34578
34579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34581 if (SWIG_arg_fail(1)) SWIG_fail;
34582 {
34583 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34584 if (SWIG_arg_fail(2)) SWIG_fail;
34585 }
34586 {
34587 PyThreadState* __tstate = wxPyBeginAllowThreads();
34588 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34589
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 {
34594 resultobj = wxPyMake_wxObject(result, 0);
34595 }
34596 return resultobj;
34597 fail:
34598 return NULL;
34599 }
34600
34601
34602 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34603 PyObject *resultobj;
34604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34605 size_t arg2 ;
34606 wxMenu *arg3 = (wxMenu *) 0 ;
34607 wxString *arg4 = 0 ;
34608 wxMenu *result;
34609 bool temp4 = false ;
34610 PyObject * obj0 = 0 ;
34611 PyObject * obj1 = 0 ;
34612 PyObject * obj2 = 0 ;
34613 PyObject * obj3 = 0 ;
34614 char *kwnames[] = {
34615 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34616 };
34617
34618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34620 if (SWIG_arg_fail(1)) SWIG_fail;
34621 {
34622 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34623 if (SWIG_arg_fail(2)) SWIG_fail;
34624 }
34625 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34626 if (SWIG_arg_fail(3)) SWIG_fail;
34627 {
34628 arg4 = wxString_in_helper(obj3);
34629 if (arg4 == NULL) SWIG_fail;
34630 temp4 = true;
34631 }
34632 {
34633 PyThreadState* __tstate = wxPyBeginAllowThreads();
34634 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34635
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 {
34640 resultobj = wxPyMake_wxObject(result, 0);
34641 }
34642 {
34643 if (temp4)
34644 delete arg4;
34645 }
34646 return resultobj;
34647 fail:
34648 {
34649 if (temp4)
34650 delete arg4;
34651 }
34652 return NULL;
34653 }
34654
34655
34656 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34657 PyObject *resultobj;
34658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34659 size_t arg2 ;
34660 wxMenu *result;
34661 PyObject * obj0 = 0 ;
34662 PyObject * obj1 = 0 ;
34663 char *kwnames[] = {
34664 (char *) "self",(char *) "pos", NULL
34665 };
34666
34667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34669 if (SWIG_arg_fail(1)) SWIG_fail;
34670 {
34671 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34672 if (SWIG_arg_fail(2)) SWIG_fail;
34673 }
34674 {
34675 PyThreadState* __tstate = wxPyBeginAllowThreads();
34676 result = (wxMenu *)(arg1)->Remove(arg2);
34677
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 {
34682 resultobj = wxPyMake_wxObject(result, 0);
34683 }
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj;
34692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34693 size_t arg2 ;
34694 bool arg3 ;
34695 PyObject * obj0 = 0 ;
34696 PyObject * obj1 = 0 ;
34697 PyObject * obj2 = 0 ;
34698 char *kwnames[] = {
34699 (char *) "self",(char *) "pos",(char *) "enable", NULL
34700 };
34701
34702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34704 if (SWIG_arg_fail(1)) SWIG_fail;
34705 {
34706 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34707 if (SWIG_arg_fail(2)) SWIG_fail;
34708 }
34709 {
34710 arg3 = (bool)(SWIG_As_bool(obj2));
34711 if (SWIG_arg_fail(3)) SWIG_fail;
34712 }
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 (arg1)->EnableTop(arg2,arg3);
34716
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 Py_INCREF(Py_None); resultobj = Py_None;
34721 return resultobj;
34722 fail:
34723 return NULL;
34724 }
34725
34726
34727 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34728 PyObject *resultobj;
34729 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34730 size_t arg2 ;
34731 bool result;
34732 PyObject * obj0 = 0 ;
34733 PyObject * obj1 = 0 ;
34734 char *kwnames[] = {
34735 (char *) "self",(char *) "pos", NULL
34736 };
34737
34738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34740 if (SWIG_arg_fail(1)) SWIG_fail;
34741 {
34742 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34743 if (SWIG_arg_fail(2)) SWIG_fail;
34744 }
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34748
34749 wxPyEndAllowThreads(__tstate);
34750 if (PyErr_Occurred()) SWIG_fail;
34751 }
34752 {
34753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34754 }
34755 return resultobj;
34756 fail:
34757 return NULL;
34758 }
34759
34760
34761 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34762 PyObject *resultobj;
34763 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34764 size_t arg2 ;
34765 wxString *arg3 = 0 ;
34766 bool temp3 = false ;
34767 PyObject * obj0 = 0 ;
34768 PyObject * obj1 = 0 ;
34769 PyObject * obj2 = 0 ;
34770 char *kwnames[] = {
34771 (char *) "self",(char *) "pos",(char *) "label", NULL
34772 };
34773
34774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34776 if (SWIG_arg_fail(1)) SWIG_fail;
34777 {
34778 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34779 if (SWIG_arg_fail(2)) SWIG_fail;
34780 }
34781 {
34782 arg3 = wxString_in_helper(obj2);
34783 if (arg3 == NULL) SWIG_fail;
34784 temp3 = true;
34785 }
34786 {
34787 PyThreadState* __tstate = wxPyBeginAllowThreads();
34788 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34789
34790 wxPyEndAllowThreads(__tstate);
34791 if (PyErr_Occurred()) SWIG_fail;
34792 }
34793 Py_INCREF(Py_None); resultobj = Py_None;
34794 {
34795 if (temp3)
34796 delete arg3;
34797 }
34798 return resultobj;
34799 fail:
34800 {
34801 if (temp3)
34802 delete arg3;
34803 }
34804 return NULL;
34805 }
34806
34807
34808 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34809 PyObject *resultobj;
34810 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34811 size_t arg2 ;
34812 wxString result;
34813 PyObject * obj0 = 0 ;
34814 PyObject * obj1 = 0 ;
34815 char *kwnames[] = {
34816 (char *) "self",(char *) "pos", NULL
34817 };
34818
34819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34821 if (SWIG_arg_fail(1)) SWIG_fail;
34822 {
34823 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34824 if (SWIG_arg_fail(2)) SWIG_fail;
34825 }
34826 {
34827 PyThreadState* __tstate = wxPyBeginAllowThreads();
34828 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34829
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 #if wxUSE_UNICODE
34835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34836 #else
34837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34838 #endif
34839 }
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj;
34848 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34849 wxString *arg2 = 0 ;
34850 wxString *arg3 = 0 ;
34851 int result;
34852 bool temp2 = false ;
34853 bool temp3 = false ;
34854 PyObject * obj0 = 0 ;
34855 PyObject * obj1 = 0 ;
34856 PyObject * obj2 = 0 ;
34857 char *kwnames[] = {
34858 (char *) "self",(char *) "menu",(char *) "item", NULL
34859 };
34860
34861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34863 if (SWIG_arg_fail(1)) SWIG_fail;
34864 {
34865 arg2 = wxString_in_helper(obj1);
34866 if (arg2 == NULL) SWIG_fail;
34867 temp2 = true;
34868 }
34869 {
34870 arg3 = wxString_in_helper(obj2);
34871 if (arg3 == NULL) SWIG_fail;
34872 temp3 = true;
34873 }
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34877
34878 wxPyEndAllowThreads(__tstate);
34879 if (PyErr_Occurred()) SWIG_fail;
34880 }
34881 {
34882 resultobj = SWIG_From_int((int)(result));
34883 }
34884 {
34885 if (temp2)
34886 delete arg2;
34887 }
34888 {
34889 if (temp3)
34890 delete arg3;
34891 }
34892 return resultobj;
34893 fail:
34894 {
34895 if (temp2)
34896 delete arg2;
34897 }
34898 {
34899 if (temp3)
34900 delete arg3;
34901 }
34902 return NULL;
34903 }
34904
34905
34906 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34907 PyObject *resultobj;
34908 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34909 int arg2 ;
34910 wxMenuItem *result;
34911 PyObject * obj0 = 0 ;
34912 PyObject * obj1 = 0 ;
34913 char *kwnames[] = {
34914 (char *) "self",(char *) "id", NULL
34915 };
34916
34917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34919 if (SWIG_arg_fail(1)) SWIG_fail;
34920 {
34921 arg2 = (int)(SWIG_As_int(obj1));
34922 if (SWIG_arg_fail(2)) SWIG_fail;
34923 }
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34927
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 {
34932 resultobj = wxPyMake_wxObject(result, 0);
34933 }
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34941 PyObject *resultobj;
34942 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34943 wxString *arg2 = 0 ;
34944 int result;
34945 bool temp2 = false ;
34946 PyObject * obj0 = 0 ;
34947 PyObject * obj1 = 0 ;
34948 char *kwnames[] = {
34949 (char *) "self",(char *) "title", NULL
34950 };
34951
34952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34954 if (SWIG_arg_fail(1)) SWIG_fail;
34955 {
34956 arg2 = wxString_in_helper(obj1);
34957 if (arg2 == NULL) SWIG_fail;
34958 temp2 = true;
34959 }
34960 {
34961 PyThreadState* __tstate = wxPyBeginAllowThreads();
34962 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34963
34964 wxPyEndAllowThreads(__tstate);
34965 if (PyErr_Occurred()) SWIG_fail;
34966 }
34967 {
34968 resultobj = SWIG_From_int((int)(result));
34969 }
34970 {
34971 if (temp2)
34972 delete arg2;
34973 }
34974 return resultobj;
34975 fail:
34976 {
34977 if (temp2)
34978 delete arg2;
34979 }
34980 return NULL;
34981 }
34982
34983
34984 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34985 PyObject *resultobj;
34986 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34987 int arg2 ;
34988 bool arg3 ;
34989 PyObject * obj0 = 0 ;
34990 PyObject * obj1 = 0 ;
34991 PyObject * obj2 = 0 ;
34992 char *kwnames[] = {
34993 (char *) "self",(char *) "id",(char *) "enable", NULL
34994 };
34995
34996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34998 if (SWIG_arg_fail(1)) SWIG_fail;
34999 {
35000 arg2 = (int)(SWIG_As_int(obj1));
35001 if (SWIG_arg_fail(2)) SWIG_fail;
35002 }
35003 {
35004 arg3 = (bool)(SWIG_As_bool(obj2));
35005 if (SWIG_arg_fail(3)) SWIG_fail;
35006 }
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 (arg1)->Enable(arg2,arg3);
35010
35011 wxPyEndAllowThreads(__tstate);
35012 if (PyErr_Occurred()) SWIG_fail;
35013 }
35014 Py_INCREF(Py_None); resultobj = Py_None;
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35022 PyObject *resultobj;
35023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35024 int arg2 ;
35025 bool arg3 ;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 PyObject * obj2 = 0 ;
35029 char *kwnames[] = {
35030 (char *) "self",(char *) "id",(char *) "check", NULL
35031 };
35032
35033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35035 if (SWIG_arg_fail(1)) SWIG_fail;
35036 {
35037 arg2 = (int)(SWIG_As_int(obj1));
35038 if (SWIG_arg_fail(2)) SWIG_fail;
35039 }
35040 {
35041 arg3 = (bool)(SWIG_As_bool(obj2));
35042 if (SWIG_arg_fail(3)) SWIG_fail;
35043 }
35044 {
35045 PyThreadState* __tstate = wxPyBeginAllowThreads();
35046 (arg1)->Check(arg2,arg3);
35047
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 Py_INCREF(Py_None); resultobj = Py_None;
35052 return resultobj;
35053 fail:
35054 return NULL;
35055 }
35056
35057
35058 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35059 PyObject *resultobj;
35060 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35061 int arg2 ;
35062 bool result;
35063 PyObject * obj0 = 0 ;
35064 PyObject * obj1 = 0 ;
35065 char *kwnames[] = {
35066 (char *) "self",(char *) "id", NULL
35067 };
35068
35069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35071 if (SWIG_arg_fail(1)) SWIG_fail;
35072 {
35073 arg2 = (int)(SWIG_As_int(obj1));
35074 if (SWIG_arg_fail(2)) SWIG_fail;
35075 }
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35079
35080 wxPyEndAllowThreads(__tstate);
35081 if (PyErr_Occurred()) SWIG_fail;
35082 }
35083 {
35084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35085 }
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj;
35094 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35095 int arg2 ;
35096 bool result;
35097 PyObject * obj0 = 0 ;
35098 PyObject * obj1 = 0 ;
35099 char *kwnames[] = {
35100 (char *) "self",(char *) "id", NULL
35101 };
35102
35103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35105 if (SWIG_arg_fail(1)) SWIG_fail;
35106 {
35107 arg2 = (int)(SWIG_As_int(obj1));
35108 if (SWIG_arg_fail(2)) SWIG_fail;
35109 }
35110 {
35111 PyThreadState* __tstate = wxPyBeginAllowThreads();
35112 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35113
35114 wxPyEndAllowThreads(__tstate);
35115 if (PyErr_Occurred()) SWIG_fail;
35116 }
35117 {
35118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35119 }
35120 return resultobj;
35121 fail:
35122 return NULL;
35123 }
35124
35125
35126 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35127 PyObject *resultobj;
35128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35129 int arg2 ;
35130 wxString *arg3 = 0 ;
35131 bool temp3 = false ;
35132 PyObject * obj0 = 0 ;
35133 PyObject * obj1 = 0 ;
35134 PyObject * obj2 = 0 ;
35135 char *kwnames[] = {
35136 (char *) "self",(char *) "id",(char *) "label", NULL
35137 };
35138
35139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35141 if (SWIG_arg_fail(1)) SWIG_fail;
35142 {
35143 arg2 = (int)(SWIG_As_int(obj1));
35144 if (SWIG_arg_fail(2)) SWIG_fail;
35145 }
35146 {
35147 arg3 = wxString_in_helper(obj2);
35148 if (arg3 == NULL) SWIG_fail;
35149 temp3 = true;
35150 }
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35154
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 Py_INCREF(Py_None); resultobj = Py_None;
35159 {
35160 if (temp3)
35161 delete arg3;
35162 }
35163 return resultobj;
35164 fail:
35165 {
35166 if (temp3)
35167 delete arg3;
35168 }
35169 return NULL;
35170 }
35171
35172
35173 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35174 PyObject *resultobj;
35175 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35176 int arg2 ;
35177 wxString result;
35178 PyObject * obj0 = 0 ;
35179 PyObject * obj1 = 0 ;
35180 char *kwnames[] = {
35181 (char *) "self",(char *) "id", NULL
35182 };
35183
35184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35186 if (SWIG_arg_fail(1)) SWIG_fail;
35187 {
35188 arg2 = (int)(SWIG_As_int(obj1));
35189 if (SWIG_arg_fail(2)) SWIG_fail;
35190 }
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35194
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 {
35199 #if wxUSE_UNICODE
35200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35201 #else
35202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35203 #endif
35204 }
35205 return resultobj;
35206 fail:
35207 return NULL;
35208 }
35209
35210
35211 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35212 PyObject *resultobj;
35213 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35214 int arg2 ;
35215 wxString *arg3 = 0 ;
35216 bool temp3 = false ;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 PyObject * obj2 = 0 ;
35220 char *kwnames[] = {
35221 (char *) "self",(char *) "id",(char *) "helpString", NULL
35222 };
35223
35224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35226 if (SWIG_arg_fail(1)) SWIG_fail;
35227 {
35228 arg2 = (int)(SWIG_As_int(obj1));
35229 if (SWIG_arg_fail(2)) SWIG_fail;
35230 }
35231 {
35232 arg3 = wxString_in_helper(obj2);
35233 if (arg3 == NULL) SWIG_fail;
35234 temp3 = true;
35235 }
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35239
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 Py_INCREF(Py_None); resultobj = Py_None;
35244 {
35245 if (temp3)
35246 delete arg3;
35247 }
35248 return resultobj;
35249 fail:
35250 {
35251 if (temp3)
35252 delete arg3;
35253 }
35254 return NULL;
35255 }
35256
35257
35258 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35259 PyObject *resultobj;
35260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35261 int arg2 ;
35262 wxString result;
35263 PyObject * obj0 = 0 ;
35264 PyObject * obj1 = 0 ;
35265 char *kwnames[] = {
35266 (char *) "self",(char *) "id", NULL
35267 };
35268
35269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35271 if (SWIG_arg_fail(1)) SWIG_fail;
35272 {
35273 arg2 = (int)(SWIG_As_int(obj1));
35274 if (SWIG_arg_fail(2)) SWIG_fail;
35275 }
35276 {
35277 PyThreadState* __tstate = wxPyBeginAllowThreads();
35278 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35279
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 {
35284 #if wxUSE_UNICODE
35285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35286 #else
35287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35288 #endif
35289 }
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj;
35298 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35299 wxFrame *result;
35300 PyObject * obj0 = 0 ;
35301 char *kwnames[] = {
35302 (char *) "self", NULL
35303 };
35304
35305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35307 if (SWIG_arg_fail(1)) SWIG_fail;
35308 {
35309 PyThreadState* __tstate = wxPyBeginAllowThreads();
35310 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35311
35312 wxPyEndAllowThreads(__tstate);
35313 if (PyErr_Occurred()) SWIG_fail;
35314 }
35315 {
35316 resultobj = wxPyMake_wxObject(result, 0);
35317 }
35318 return resultobj;
35319 fail:
35320 return NULL;
35321 }
35322
35323
35324 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35325 PyObject *resultobj;
35326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35327 bool result;
35328 PyObject * obj0 = 0 ;
35329 char *kwnames[] = {
35330 (char *) "self", NULL
35331 };
35332
35333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35335 if (SWIG_arg_fail(1)) SWIG_fail;
35336 {
35337 PyThreadState* __tstate = wxPyBeginAllowThreads();
35338 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35339
35340 wxPyEndAllowThreads(__tstate);
35341 if (PyErr_Occurred()) SWIG_fail;
35342 }
35343 {
35344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35345 }
35346 return resultobj;
35347 fail:
35348 return NULL;
35349 }
35350
35351
35352 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35353 PyObject *resultobj;
35354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35355 wxFrame *arg2 = (wxFrame *) 0 ;
35356 PyObject * obj0 = 0 ;
35357 PyObject * obj1 = 0 ;
35358 char *kwnames[] = {
35359 (char *) "self",(char *) "frame", NULL
35360 };
35361
35362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35364 if (SWIG_arg_fail(1)) SWIG_fail;
35365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35366 if (SWIG_arg_fail(2)) SWIG_fail;
35367 {
35368 PyThreadState* __tstate = wxPyBeginAllowThreads();
35369 (arg1)->Attach(arg2);
35370
35371 wxPyEndAllowThreads(__tstate);
35372 if (PyErr_Occurred()) SWIG_fail;
35373 }
35374 Py_INCREF(Py_None); resultobj = Py_None;
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35382 PyObject *resultobj;
35383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35384 PyObject * obj0 = 0 ;
35385 char *kwnames[] = {
35386 (char *) "self", NULL
35387 };
35388
35389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35391 if (SWIG_arg_fail(1)) SWIG_fail;
35392 {
35393 PyThreadState* __tstate = wxPyBeginAllowThreads();
35394 (arg1)->Detach();
35395
35396 wxPyEndAllowThreads(__tstate);
35397 if (PyErr_Occurred()) SWIG_fail;
35398 }
35399 Py_INCREF(Py_None); resultobj = Py_None;
35400 return resultobj;
35401 fail:
35402 return NULL;
35403 }
35404
35405
35406 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35407 PyObject *obj;
35408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35409 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35410 Py_INCREF(obj);
35411 return Py_BuildValue((char *)"");
35412 }
35413 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35414 PyObject *resultobj;
35415 wxMenu *arg1 = (wxMenu *) NULL ;
35416 int arg2 = (int) wxID_ANY ;
35417 wxString const &arg3_defvalue = wxPyEmptyString ;
35418 wxString *arg3 = (wxString *) &arg3_defvalue ;
35419 wxString const &arg4_defvalue = wxPyEmptyString ;
35420 wxString *arg4 = (wxString *) &arg4_defvalue ;
35421 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35422 wxMenu *arg6 = (wxMenu *) NULL ;
35423 wxMenuItem *result;
35424 bool temp3 = false ;
35425 bool temp4 = false ;
35426 PyObject * obj0 = 0 ;
35427 PyObject * obj1 = 0 ;
35428 PyObject * obj2 = 0 ;
35429 PyObject * obj3 = 0 ;
35430 PyObject * obj4 = 0 ;
35431 PyObject * obj5 = 0 ;
35432 char *kwnames[] = {
35433 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35434 };
35435
35436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35437 if (obj0) {
35438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35439 if (SWIG_arg_fail(1)) SWIG_fail;
35440 }
35441 if (obj1) {
35442 {
35443 arg2 = (int)(SWIG_As_int(obj1));
35444 if (SWIG_arg_fail(2)) SWIG_fail;
35445 }
35446 }
35447 if (obj2) {
35448 {
35449 arg3 = wxString_in_helper(obj2);
35450 if (arg3 == NULL) SWIG_fail;
35451 temp3 = true;
35452 }
35453 }
35454 if (obj3) {
35455 {
35456 arg4 = wxString_in_helper(obj3);
35457 if (arg4 == NULL) SWIG_fail;
35458 temp4 = true;
35459 }
35460 }
35461 if (obj4) {
35462 {
35463 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35464 if (SWIG_arg_fail(5)) SWIG_fail;
35465 }
35466 }
35467 if (obj5) {
35468 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35469 if (SWIG_arg_fail(6)) SWIG_fail;
35470 }
35471 {
35472 PyThreadState* __tstate = wxPyBeginAllowThreads();
35473 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35474
35475 wxPyEndAllowThreads(__tstate);
35476 if (PyErr_Occurred()) SWIG_fail;
35477 }
35478 {
35479 resultobj = wxPyMake_wxObject(result, 1);
35480 }
35481 {
35482 if (temp3)
35483 delete arg3;
35484 }
35485 {
35486 if (temp4)
35487 delete arg4;
35488 }
35489 return resultobj;
35490 fail:
35491 {
35492 if (temp3)
35493 delete arg3;
35494 }
35495 {
35496 if (temp4)
35497 delete arg4;
35498 }
35499 return NULL;
35500 }
35501
35502
35503 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35504 PyObject *resultobj;
35505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35506 wxMenu *result;
35507 PyObject * obj0 = 0 ;
35508 char *kwnames[] = {
35509 (char *) "self", NULL
35510 };
35511
35512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35514 if (SWIG_arg_fail(1)) SWIG_fail;
35515 {
35516 PyThreadState* __tstate = wxPyBeginAllowThreads();
35517 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35518
35519 wxPyEndAllowThreads(__tstate);
35520 if (PyErr_Occurred()) SWIG_fail;
35521 }
35522 {
35523 resultobj = wxPyMake_wxObject(result, 0);
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj;
35533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35534 wxMenu *arg2 = (wxMenu *) 0 ;
35535 PyObject * obj0 = 0 ;
35536 PyObject * obj1 = 0 ;
35537 char *kwnames[] = {
35538 (char *) "self",(char *) "menu", NULL
35539 };
35540
35541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35543 if (SWIG_arg_fail(1)) SWIG_fail;
35544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35545 if (SWIG_arg_fail(2)) SWIG_fail;
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 (arg1)->SetMenu(arg2);
35549
35550 wxPyEndAllowThreads(__tstate);
35551 if (PyErr_Occurred()) SWIG_fail;
35552 }
35553 Py_INCREF(Py_None); resultobj = Py_None;
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35561 PyObject *resultobj;
35562 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35563 int arg2 ;
35564 PyObject * obj0 = 0 ;
35565 PyObject * obj1 = 0 ;
35566 char *kwnames[] = {
35567 (char *) "self",(char *) "id", NULL
35568 };
35569
35570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35572 if (SWIG_arg_fail(1)) SWIG_fail;
35573 {
35574 arg2 = (int)(SWIG_As_int(obj1));
35575 if (SWIG_arg_fail(2)) SWIG_fail;
35576 }
35577 {
35578 PyThreadState* __tstate = wxPyBeginAllowThreads();
35579 (arg1)->SetId(arg2);
35580
35581 wxPyEndAllowThreads(__tstate);
35582 if (PyErr_Occurred()) SWIG_fail;
35583 }
35584 Py_INCREF(Py_None); resultobj = Py_None;
35585 return resultobj;
35586 fail:
35587 return NULL;
35588 }
35589
35590
35591 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35592 PyObject *resultobj;
35593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35594 int result;
35595 PyObject * obj0 = 0 ;
35596 char *kwnames[] = {
35597 (char *) "self", NULL
35598 };
35599
35600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35602 if (SWIG_arg_fail(1)) SWIG_fail;
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 result = (int)((wxMenuItem const *)arg1)->GetId();
35606
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 {
35611 resultobj = SWIG_From_int((int)(result));
35612 }
35613 return resultobj;
35614 fail:
35615 return NULL;
35616 }
35617
35618
35619 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35620 PyObject *resultobj;
35621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35622 bool result;
35623 PyObject * obj0 = 0 ;
35624 char *kwnames[] = {
35625 (char *) "self", NULL
35626 };
35627
35628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35630 if (SWIG_arg_fail(1)) SWIG_fail;
35631 {
35632 PyThreadState* __tstate = wxPyBeginAllowThreads();
35633 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35634
35635 wxPyEndAllowThreads(__tstate);
35636 if (PyErr_Occurred()) SWIG_fail;
35637 }
35638 {
35639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35640 }
35641 return resultobj;
35642 fail:
35643 return NULL;
35644 }
35645
35646
35647 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35648 PyObject *resultobj;
35649 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35650 wxString *arg2 = 0 ;
35651 bool temp2 = false ;
35652 PyObject * obj0 = 0 ;
35653 PyObject * obj1 = 0 ;
35654 char *kwnames[] = {
35655 (char *) "self",(char *) "str", NULL
35656 };
35657
35658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35660 if (SWIG_arg_fail(1)) SWIG_fail;
35661 {
35662 arg2 = wxString_in_helper(obj1);
35663 if (arg2 == NULL) SWIG_fail;
35664 temp2 = true;
35665 }
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 (arg1)->SetText((wxString const &)*arg2);
35669
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 Py_INCREF(Py_None); resultobj = Py_None;
35674 {
35675 if (temp2)
35676 delete arg2;
35677 }
35678 return resultobj;
35679 fail:
35680 {
35681 if (temp2)
35682 delete arg2;
35683 }
35684 return NULL;
35685 }
35686
35687
35688 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35689 PyObject *resultobj;
35690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35691 wxString result;
35692 PyObject * obj0 = 0 ;
35693 char *kwnames[] = {
35694 (char *) "self", NULL
35695 };
35696
35697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35699 if (SWIG_arg_fail(1)) SWIG_fail;
35700 {
35701 PyThreadState* __tstate = wxPyBeginAllowThreads();
35702 result = ((wxMenuItem const *)arg1)->GetLabel();
35703
35704 wxPyEndAllowThreads(__tstate);
35705 if (PyErr_Occurred()) SWIG_fail;
35706 }
35707 {
35708 #if wxUSE_UNICODE
35709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35710 #else
35711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35712 #endif
35713 }
35714 return resultobj;
35715 fail:
35716 return NULL;
35717 }
35718
35719
35720 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35721 PyObject *resultobj;
35722 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35723 wxString *result;
35724 PyObject * obj0 = 0 ;
35725 char *kwnames[] = {
35726 (char *) "self", NULL
35727 };
35728
35729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35731 if (SWIG_arg_fail(1)) SWIG_fail;
35732 {
35733 PyThreadState* __tstate = wxPyBeginAllowThreads();
35734 {
35735 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35736 result = (wxString *) &_result_ref;
35737 }
35738
35739 wxPyEndAllowThreads(__tstate);
35740 if (PyErr_Occurred()) SWIG_fail;
35741 }
35742 {
35743 #if wxUSE_UNICODE
35744 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35745 #else
35746 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35747 #endif
35748 }
35749 return resultobj;
35750 fail:
35751 return NULL;
35752 }
35753
35754
35755 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35756 PyObject *resultobj;
35757 wxString *arg1 = 0 ;
35758 wxString result;
35759 bool temp1 = false ;
35760 PyObject * obj0 = 0 ;
35761 char *kwnames[] = {
35762 (char *) "text", NULL
35763 };
35764
35765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35766 {
35767 arg1 = wxString_in_helper(obj0);
35768 if (arg1 == NULL) SWIG_fail;
35769 temp1 = true;
35770 }
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35774
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 {
35779 #if wxUSE_UNICODE
35780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35781 #else
35782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35783 #endif
35784 }
35785 {
35786 if (temp1)
35787 delete arg1;
35788 }
35789 return resultobj;
35790 fail:
35791 {
35792 if (temp1)
35793 delete arg1;
35794 }
35795 return NULL;
35796 }
35797
35798
35799 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35800 PyObject *resultobj;
35801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35802 wxItemKind result;
35803 PyObject * obj0 = 0 ;
35804 char *kwnames[] = {
35805 (char *) "self", NULL
35806 };
35807
35808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35810 if (SWIG_arg_fail(1)) SWIG_fail;
35811 {
35812 PyThreadState* __tstate = wxPyBeginAllowThreads();
35813 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35814
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 resultobj = SWIG_From_int((result));
35819 return resultobj;
35820 fail:
35821 return NULL;
35822 }
35823
35824
35825 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35826 PyObject *resultobj;
35827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35828 wxItemKind arg2 ;
35829 PyObject * obj0 = 0 ;
35830 PyObject * obj1 = 0 ;
35831 char *kwnames[] = {
35832 (char *) "self",(char *) "kind", NULL
35833 };
35834
35835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35837 if (SWIG_arg_fail(1)) SWIG_fail;
35838 {
35839 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35840 if (SWIG_arg_fail(2)) SWIG_fail;
35841 }
35842 {
35843 PyThreadState* __tstate = wxPyBeginAllowThreads();
35844 (arg1)->SetKind((wxItemKind )arg2);
35845
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 Py_INCREF(Py_None); resultobj = Py_None;
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj;
35858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35859 bool arg2 ;
35860 PyObject * obj0 = 0 ;
35861 PyObject * obj1 = 0 ;
35862 char *kwnames[] = {
35863 (char *) "self",(char *) "checkable", NULL
35864 };
35865
35866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35868 if (SWIG_arg_fail(1)) SWIG_fail;
35869 {
35870 arg2 = (bool)(SWIG_As_bool(obj1));
35871 if (SWIG_arg_fail(2)) SWIG_fail;
35872 }
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 (arg1)->SetCheckable(arg2);
35876
35877 wxPyEndAllowThreads(__tstate);
35878 if (PyErr_Occurred()) SWIG_fail;
35879 }
35880 Py_INCREF(Py_None); resultobj = Py_None;
35881 return resultobj;
35882 fail:
35883 return NULL;
35884 }
35885
35886
35887 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35888 PyObject *resultobj;
35889 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35890 bool result;
35891 PyObject * obj0 = 0 ;
35892 char *kwnames[] = {
35893 (char *) "self", NULL
35894 };
35895
35896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35898 if (SWIG_arg_fail(1)) SWIG_fail;
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35902
35903 wxPyEndAllowThreads(__tstate);
35904 if (PyErr_Occurred()) SWIG_fail;
35905 }
35906 {
35907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35908 }
35909 return resultobj;
35910 fail:
35911 return NULL;
35912 }
35913
35914
35915 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35916 PyObject *resultobj;
35917 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35918 bool result;
35919 PyObject * obj0 = 0 ;
35920 char *kwnames[] = {
35921 (char *) "self", NULL
35922 };
35923
35924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35926 if (SWIG_arg_fail(1)) SWIG_fail;
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35930
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 {
35935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35936 }
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj;
35945 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35946 wxMenu *arg2 = (wxMenu *) 0 ;
35947 PyObject * obj0 = 0 ;
35948 PyObject * obj1 = 0 ;
35949 char *kwnames[] = {
35950 (char *) "self",(char *) "menu", NULL
35951 };
35952
35953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(1)) SWIG_fail;
35956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35957 if (SWIG_arg_fail(2)) SWIG_fail;
35958 {
35959 PyThreadState* __tstate = wxPyBeginAllowThreads();
35960 (arg1)->SetSubMenu(arg2);
35961
35962 wxPyEndAllowThreads(__tstate);
35963 if (PyErr_Occurred()) SWIG_fail;
35964 }
35965 Py_INCREF(Py_None); resultobj = Py_None;
35966 return resultobj;
35967 fail:
35968 return NULL;
35969 }
35970
35971
35972 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj;
35974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35975 wxMenu *result;
35976 PyObject * obj0 = 0 ;
35977 char *kwnames[] = {
35978 (char *) "self", NULL
35979 };
35980
35981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35983 if (SWIG_arg_fail(1)) SWIG_fail;
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35987
35988 wxPyEndAllowThreads(__tstate);
35989 if (PyErr_Occurred()) SWIG_fail;
35990 }
35991 {
35992 resultobj = wxPyMake_wxObject(result, 0);
35993 }
35994 return resultobj;
35995 fail:
35996 return NULL;
35997 }
35998
35999
36000 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36001 PyObject *resultobj;
36002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36003 bool arg2 = (bool) true ;
36004 PyObject * obj0 = 0 ;
36005 PyObject * obj1 = 0 ;
36006 char *kwnames[] = {
36007 (char *) "self",(char *) "enable", NULL
36008 };
36009
36010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36012 if (SWIG_arg_fail(1)) SWIG_fail;
36013 if (obj1) {
36014 {
36015 arg2 = (bool)(SWIG_As_bool(obj1));
36016 if (SWIG_arg_fail(2)) SWIG_fail;
36017 }
36018 }
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 (arg1)->Enable(arg2);
36022
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 Py_INCREF(Py_None); resultobj = Py_None;
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj;
36035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36036 bool result;
36037 PyObject * obj0 = 0 ;
36038 char *kwnames[] = {
36039 (char *) "self", NULL
36040 };
36041
36042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36044 if (SWIG_arg_fail(1)) SWIG_fail;
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36048
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj;
36063 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36064 bool arg2 = (bool) true ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char *kwnames[] = {
36068 (char *) "self",(char *) "check", NULL
36069 };
36070
36071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36073 if (SWIG_arg_fail(1)) SWIG_fail;
36074 if (obj1) {
36075 {
36076 arg2 = (bool)(SWIG_As_bool(obj1));
36077 if (SWIG_arg_fail(2)) SWIG_fail;
36078 }
36079 }
36080 {
36081 PyThreadState* __tstate = wxPyBeginAllowThreads();
36082 (arg1)->Check(arg2);
36083
36084 wxPyEndAllowThreads(__tstate);
36085 if (PyErr_Occurred()) SWIG_fail;
36086 }
36087 Py_INCREF(Py_None); resultobj = Py_None;
36088 return resultobj;
36089 fail:
36090 return NULL;
36091 }
36092
36093
36094 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36095 PyObject *resultobj;
36096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36097 bool result;
36098 PyObject * obj0 = 0 ;
36099 char *kwnames[] = {
36100 (char *) "self", NULL
36101 };
36102
36103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36105 if (SWIG_arg_fail(1)) SWIG_fail;
36106 {
36107 PyThreadState* __tstate = wxPyBeginAllowThreads();
36108 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36109
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 {
36114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36115 }
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj;
36124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36125 PyObject * obj0 = 0 ;
36126 char *kwnames[] = {
36127 (char *) "self", NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36132 if (SWIG_arg_fail(1)) SWIG_fail;
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 (arg1)->Toggle();
36136
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 Py_INCREF(Py_None); resultobj = Py_None;
36141 return resultobj;
36142 fail:
36143 return NULL;
36144 }
36145
36146
36147 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36148 PyObject *resultobj;
36149 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36150 wxString *arg2 = 0 ;
36151 bool temp2 = false ;
36152 PyObject * obj0 = 0 ;
36153 PyObject * obj1 = 0 ;
36154 char *kwnames[] = {
36155 (char *) "self",(char *) "str", NULL
36156 };
36157
36158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(1)) SWIG_fail;
36161 {
36162 arg2 = wxString_in_helper(obj1);
36163 if (arg2 == NULL) SWIG_fail;
36164 temp2 = true;
36165 }
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 (arg1)->SetHelp((wxString const &)*arg2);
36169
36170 wxPyEndAllowThreads(__tstate);
36171 if (PyErr_Occurred()) SWIG_fail;
36172 }
36173 Py_INCREF(Py_None); resultobj = Py_None;
36174 {
36175 if (temp2)
36176 delete arg2;
36177 }
36178 return resultobj;
36179 fail:
36180 {
36181 if (temp2)
36182 delete arg2;
36183 }
36184 return NULL;
36185 }
36186
36187
36188 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36189 PyObject *resultobj;
36190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36191 wxString *result;
36192 PyObject * obj0 = 0 ;
36193 char *kwnames[] = {
36194 (char *) "self", NULL
36195 };
36196
36197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36199 if (SWIG_arg_fail(1)) SWIG_fail;
36200 {
36201 PyThreadState* __tstate = wxPyBeginAllowThreads();
36202 {
36203 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36204 result = (wxString *) &_result_ref;
36205 }
36206
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 {
36211 #if wxUSE_UNICODE
36212 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36213 #else
36214 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36215 #endif
36216 }
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36224 PyObject *resultobj;
36225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36226 wxAcceleratorEntry *result;
36227 PyObject * obj0 = 0 ;
36228 char *kwnames[] = {
36229 (char *) "self", NULL
36230 };
36231
36232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36234 if (SWIG_arg_fail(1)) SWIG_fail;
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36238
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36250 PyObject *resultobj;
36251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36252 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36253 PyObject * obj0 = 0 ;
36254 PyObject * obj1 = 0 ;
36255 char *kwnames[] = {
36256 (char *) "self",(char *) "accel", NULL
36257 };
36258
36259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(1)) SWIG_fail;
36262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36263 if (SWIG_arg_fail(2)) SWIG_fail;
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 (arg1)->SetAccel(arg2);
36267
36268 wxPyEndAllowThreads(__tstate);
36269 if (PyErr_Occurred()) SWIG_fail;
36270 }
36271 Py_INCREF(Py_None); resultobj = Py_None;
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj;
36280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36281 wxFont *arg2 = 0 ;
36282 PyObject * obj0 = 0 ;
36283 PyObject * obj1 = 0 ;
36284 char *kwnames[] = {
36285 (char *) "self",(char *) "font", NULL
36286 };
36287
36288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36290 if (SWIG_arg_fail(1)) SWIG_fail;
36291 {
36292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36293 if (SWIG_arg_fail(2)) SWIG_fail;
36294 if (arg2 == NULL) {
36295 SWIG_null_ref("wxFont");
36296 }
36297 if (SWIG_arg_fail(2)) SWIG_fail;
36298 }
36299 {
36300 PyThreadState* __tstate = wxPyBeginAllowThreads();
36301 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36302
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 Py_INCREF(Py_None); resultobj = Py_None;
36307 return resultobj;
36308 fail:
36309 return NULL;
36310 }
36311
36312
36313 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36314 PyObject *resultobj;
36315 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36316 wxFont result;
36317 PyObject * obj0 = 0 ;
36318 char *kwnames[] = {
36319 (char *) "self", NULL
36320 };
36321
36322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 result = wxMenuItem_GetFont(arg1);
36328
36329 wxPyEndAllowThreads(__tstate);
36330 if (PyErr_Occurred()) SWIG_fail;
36331 }
36332 {
36333 wxFont * resultptr;
36334 resultptr = new wxFont((wxFont &)(result));
36335 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36336 }
36337 return resultobj;
36338 fail:
36339 return NULL;
36340 }
36341
36342
36343 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36344 PyObject *resultobj;
36345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36346 wxColour *arg2 = 0 ;
36347 wxColour temp2 ;
36348 PyObject * obj0 = 0 ;
36349 PyObject * obj1 = 0 ;
36350 char *kwnames[] = {
36351 (char *) "self",(char *) "colText", NULL
36352 };
36353
36354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36356 if (SWIG_arg_fail(1)) SWIG_fail;
36357 {
36358 arg2 = &temp2;
36359 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36360 }
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36364
36365 wxPyEndAllowThreads(__tstate);
36366 if (PyErr_Occurred()) SWIG_fail;
36367 }
36368 Py_INCREF(Py_None); resultobj = Py_None;
36369 return resultobj;
36370 fail:
36371 return NULL;
36372 }
36373
36374
36375 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36376 PyObject *resultobj;
36377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36378 wxColour result;
36379 PyObject * obj0 = 0 ;
36380 char *kwnames[] = {
36381 (char *) "self", NULL
36382 };
36383
36384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36386 if (SWIG_arg_fail(1)) SWIG_fail;
36387 {
36388 PyThreadState* __tstate = wxPyBeginAllowThreads();
36389 result = wxMenuItem_GetTextColour(arg1);
36390
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 {
36395 wxColour * resultptr;
36396 resultptr = new wxColour((wxColour &)(result));
36397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36398 }
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36406 PyObject *resultobj;
36407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36408 wxColour *arg2 = 0 ;
36409 wxColour temp2 ;
36410 PyObject * obj0 = 0 ;
36411 PyObject * obj1 = 0 ;
36412 char *kwnames[] = {
36413 (char *) "self",(char *) "colBack", NULL
36414 };
36415
36416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36418 if (SWIG_arg_fail(1)) SWIG_fail;
36419 {
36420 arg2 = &temp2;
36421 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36422 }
36423 {
36424 PyThreadState* __tstate = wxPyBeginAllowThreads();
36425 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36426
36427 wxPyEndAllowThreads(__tstate);
36428 if (PyErr_Occurred()) SWIG_fail;
36429 }
36430 Py_INCREF(Py_None); resultobj = Py_None;
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36438 PyObject *resultobj;
36439 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36440 wxColour result;
36441 PyObject * obj0 = 0 ;
36442 char *kwnames[] = {
36443 (char *) "self", NULL
36444 };
36445
36446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36448 if (SWIG_arg_fail(1)) SWIG_fail;
36449 {
36450 PyThreadState* __tstate = wxPyBeginAllowThreads();
36451 result = wxMenuItem_GetBackgroundColour(arg1);
36452
36453 wxPyEndAllowThreads(__tstate);
36454 if (PyErr_Occurred()) SWIG_fail;
36455 }
36456 {
36457 wxColour * resultptr;
36458 resultptr = new wxColour((wxColour &)(result));
36459 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36460 }
36461 return resultobj;
36462 fail:
36463 return NULL;
36464 }
36465
36466
36467 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36468 PyObject *resultobj;
36469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36470 wxBitmap *arg2 = 0 ;
36471 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36472 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 PyObject * obj2 = 0 ;
36476 char *kwnames[] = {
36477 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36478 };
36479
36480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36482 if (SWIG_arg_fail(1)) SWIG_fail;
36483 {
36484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36485 if (SWIG_arg_fail(2)) SWIG_fail;
36486 if (arg2 == NULL) {
36487 SWIG_null_ref("wxBitmap");
36488 }
36489 if (SWIG_arg_fail(2)) SWIG_fail;
36490 }
36491 if (obj2) {
36492 {
36493 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36494 if (SWIG_arg_fail(3)) SWIG_fail;
36495 if (arg3 == NULL) {
36496 SWIG_null_ref("wxBitmap");
36497 }
36498 if (SWIG_arg_fail(3)) SWIG_fail;
36499 }
36500 }
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36504
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 Py_INCREF(Py_None); resultobj = Py_None;
36509 return resultobj;
36510 fail:
36511 return NULL;
36512 }
36513
36514
36515 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36516 PyObject *resultobj;
36517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36518 wxBitmap *arg2 = 0 ;
36519 PyObject * obj0 = 0 ;
36520 PyObject * obj1 = 0 ;
36521 char *kwnames[] = {
36522 (char *) "self",(char *) "bmpDisabled", NULL
36523 };
36524
36525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36527 if (SWIG_arg_fail(1)) SWIG_fail;
36528 {
36529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36530 if (SWIG_arg_fail(2)) SWIG_fail;
36531 if (arg2 == NULL) {
36532 SWIG_null_ref("wxBitmap");
36533 }
36534 if (SWIG_arg_fail(2)) SWIG_fail;
36535 }
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36539
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 Py_INCREF(Py_None); resultobj = Py_None;
36544 return resultobj;
36545 fail:
36546 return NULL;
36547 }
36548
36549
36550 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36551 PyObject *resultobj;
36552 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36553 wxBitmap *result;
36554 PyObject * obj0 = 0 ;
36555 char *kwnames[] = {
36556 (char *) "self", NULL
36557 };
36558
36559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36561 if (SWIG_arg_fail(1)) SWIG_fail;
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 {
36565 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36566 result = (wxBitmap *) &_result_ref;
36567 }
36568
36569 wxPyEndAllowThreads(__tstate);
36570 if (PyErr_Occurred()) SWIG_fail;
36571 }
36572 {
36573 wxBitmap* resultptr = new wxBitmap(*result);
36574 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36575 }
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36583 PyObject *resultobj;
36584 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36585 int arg2 ;
36586 PyObject * obj0 = 0 ;
36587 PyObject * obj1 = 0 ;
36588 char *kwnames[] = {
36589 (char *) "self",(char *) "nWidth", NULL
36590 };
36591
36592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36594 if (SWIG_arg_fail(1)) SWIG_fail;
36595 {
36596 arg2 = (int)(SWIG_As_int(obj1));
36597 if (SWIG_arg_fail(2)) SWIG_fail;
36598 }
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 wxMenuItem_SetMarginWidth(arg1,arg2);
36602
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 Py_INCREF(Py_None); resultobj = Py_None;
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36614 PyObject *resultobj;
36615 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36616 int result;
36617 PyObject * obj0 = 0 ;
36618 char *kwnames[] = {
36619 (char *) "self", NULL
36620 };
36621
36622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36624 if (SWIG_arg_fail(1)) SWIG_fail;
36625 {
36626 PyThreadState* __tstate = wxPyBeginAllowThreads();
36627 result = (int)wxMenuItem_GetMarginWidth(arg1);
36628
36629 wxPyEndAllowThreads(__tstate);
36630 if (PyErr_Occurred()) SWIG_fail;
36631 }
36632 {
36633 resultobj = SWIG_From_int((int)(result));
36634 }
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36642 PyObject *resultobj;
36643 int result;
36644 char *kwnames[] = {
36645 NULL
36646 };
36647
36648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36649 {
36650 PyThreadState* __tstate = wxPyBeginAllowThreads();
36651 result = (int)MenuItem_GetDefaultMarginWidth();
36652
36653 wxPyEndAllowThreads(__tstate);
36654 if (PyErr_Occurred()) SWIG_fail;
36655 }
36656 {
36657 resultobj = SWIG_From_int((int)(result));
36658 }
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj;
36667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36668 bool result;
36669 PyObject * obj0 = 0 ;
36670 char *kwnames[] = {
36671 (char *) "self", NULL
36672 };
36673
36674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36676 if (SWIG_arg_fail(1)) SWIG_fail;
36677 {
36678 PyThreadState* __tstate = wxPyBeginAllowThreads();
36679 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
36680
36681 wxPyEndAllowThreads(__tstate);
36682 if (PyErr_Occurred()) SWIG_fail;
36683 }
36684 {
36685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36686 }
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj;
36695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36696 bool arg2 = (bool) true ;
36697 PyObject * obj0 = 0 ;
36698 PyObject * obj1 = 0 ;
36699 char *kwnames[] = {
36700 (char *) "self",(char *) "ownerDrawn", NULL
36701 };
36702
36703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36705 if (SWIG_arg_fail(1)) SWIG_fail;
36706 if (obj1) {
36707 {
36708 arg2 = (bool)(SWIG_As_bool(obj1));
36709 if (SWIG_arg_fail(2)) SWIG_fail;
36710 }
36711 }
36712 {
36713 PyThreadState* __tstate = wxPyBeginAllowThreads();
36714 wxMenuItem_SetOwnerDrawn(arg1,arg2);
36715
36716 wxPyEndAllowThreads(__tstate);
36717 if (PyErr_Occurred()) SWIG_fail;
36718 }
36719 Py_INCREF(Py_None); resultobj = Py_None;
36720 return resultobj;
36721 fail:
36722 return NULL;
36723 }
36724
36725
36726 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36727 PyObject *resultobj;
36728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36729 PyObject * obj0 = 0 ;
36730 char *kwnames[] = {
36731 (char *) "self", NULL
36732 };
36733
36734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36736 if (SWIG_arg_fail(1)) SWIG_fail;
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 wxMenuItem_ResetOwnerDrawn(arg1);
36740
36741 wxPyEndAllowThreads(__tstate);
36742 if (PyErr_Occurred()) SWIG_fail;
36743 }
36744 Py_INCREF(Py_None); resultobj = Py_None;
36745 return resultobj;
36746 fail:
36747 return NULL;
36748 }
36749
36750
36751 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36752 PyObject *resultobj;
36753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36754 wxBitmap *arg2 = 0 ;
36755 PyObject * obj0 = 0 ;
36756 PyObject * obj1 = 0 ;
36757 char *kwnames[] = {
36758 (char *) "self",(char *) "bitmap", NULL
36759 };
36760
36761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36763 if (SWIG_arg_fail(1)) SWIG_fail;
36764 {
36765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36766 if (SWIG_arg_fail(2)) SWIG_fail;
36767 if (arg2 == NULL) {
36768 SWIG_null_ref("wxBitmap");
36769 }
36770 if (SWIG_arg_fail(2)) SWIG_fail;
36771 }
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36775
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 Py_INCREF(Py_None); resultobj = Py_None;
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36787 PyObject *resultobj;
36788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36789 wxBitmap *result;
36790 PyObject * obj0 = 0 ;
36791 char *kwnames[] = {
36792 (char *) "self", NULL
36793 };
36794
36795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36797 if (SWIG_arg_fail(1)) SWIG_fail;
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 {
36801 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36802 result = (wxBitmap *) &_result_ref;
36803 }
36804
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 {
36809 wxBitmap* resultptr = new wxBitmap(*result);
36810 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36811 }
36812 return resultobj;
36813 fail:
36814 return NULL;
36815 }
36816
36817
36818 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36819 PyObject *obj;
36820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36821 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36822 Py_INCREF(obj);
36823 return Py_BuildValue((char *)"");
36824 }
36825 static int _wrap_ControlNameStr_set(PyObject *) {
36826 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36827 return 1;
36828 }
36829
36830
36831 static PyObject *_wrap_ControlNameStr_get(void) {
36832 PyObject *pyobj;
36833
36834 {
36835 #if wxUSE_UNICODE
36836 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36837 #else
36838 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36839 #endif
36840 }
36841 return pyobj;
36842 }
36843
36844
36845 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 int arg2 = (int) -1 ;
36849 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36850 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36851 wxSize const &arg4_defvalue = wxDefaultSize ;
36852 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36853 long arg5 = (long) 0 ;
36854 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36855 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36856 wxString const &arg7_defvalue = wxPyControlNameStr ;
36857 wxString *arg7 = (wxString *) &arg7_defvalue ;
36858 wxControl *result;
36859 wxPoint temp3 ;
36860 wxSize temp4 ;
36861 bool temp7 = false ;
36862 PyObject * obj0 = 0 ;
36863 PyObject * obj1 = 0 ;
36864 PyObject * obj2 = 0 ;
36865 PyObject * obj3 = 0 ;
36866 PyObject * obj4 = 0 ;
36867 PyObject * obj5 = 0 ;
36868 PyObject * obj6 = 0 ;
36869 char *kwnames[] = {
36870 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36871 };
36872
36873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36875 if (SWIG_arg_fail(1)) SWIG_fail;
36876 if (obj1) {
36877 {
36878 arg2 = (int)(SWIG_As_int(obj1));
36879 if (SWIG_arg_fail(2)) SWIG_fail;
36880 }
36881 }
36882 if (obj2) {
36883 {
36884 arg3 = &temp3;
36885 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36886 }
36887 }
36888 if (obj3) {
36889 {
36890 arg4 = &temp4;
36891 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36892 }
36893 }
36894 if (obj4) {
36895 {
36896 arg5 = (long)(SWIG_As_long(obj4));
36897 if (SWIG_arg_fail(5)) SWIG_fail;
36898 }
36899 }
36900 if (obj5) {
36901 {
36902 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36903 if (SWIG_arg_fail(6)) SWIG_fail;
36904 if (arg6 == NULL) {
36905 SWIG_null_ref("wxValidator");
36906 }
36907 if (SWIG_arg_fail(6)) SWIG_fail;
36908 }
36909 }
36910 if (obj6) {
36911 {
36912 arg7 = wxString_in_helper(obj6);
36913 if (arg7 == NULL) SWIG_fail;
36914 temp7 = true;
36915 }
36916 }
36917 {
36918 if (!wxPyCheckForApp()) SWIG_fail;
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36921
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36926 {
36927 if (temp7)
36928 delete arg7;
36929 }
36930 return resultobj;
36931 fail:
36932 {
36933 if (temp7)
36934 delete arg7;
36935 }
36936 return NULL;
36937 }
36938
36939
36940 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36941 PyObject *resultobj;
36942 wxControl *result;
36943 char *kwnames[] = {
36944 NULL
36945 };
36946
36947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36948 {
36949 if (!wxPyCheckForApp()) SWIG_fail;
36950 PyThreadState* __tstate = wxPyBeginAllowThreads();
36951 result = (wxControl *)new wxControl();
36952
36953 wxPyEndAllowThreads(__tstate);
36954 if (PyErr_Occurred()) SWIG_fail;
36955 }
36956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36957 return resultobj;
36958 fail:
36959 return NULL;
36960 }
36961
36962
36963 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36964 PyObject *resultobj;
36965 wxControl *arg1 = (wxControl *) 0 ;
36966 wxWindow *arg2 = (wxWindow *) 0 ;
36967 int arg3 = (int) -1 ;
36968 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36969 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36970 wxSize const &arg5_defvalue = wxDefaultSize ;
36971 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36972 long arg6 = (long) 0 ;
36973 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36974 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36975 wxString const &arg8_defvalue = wxPyControlNameStr ;
36976 wxString *arg8 = (wxString *) &arg8_defvalue ;
36977 bool result;
36978 wxPoint temp4 ;
36979 wxSize temp5 ;
36980 bool temp8 = false ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 PyObject * obj2 = 0 ;
36984 PyObject * obj3 = 0 ;
36985 PyObject * obj4 = 0 ;
36986 PyObject * obj5 = 0 ;
36987 PyObject * obj6 = 0 ;
36988 PyObject * obj7 = 0 ;
36989 char *kwnames[] = {
36990 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36991 };
36992
36993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36995 if (SWIG_arg_fail(1)) SWIG_fail;
36996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36997 if (SWIG_arg_fail(2)) SWIG_fail;
36998 if (obj2) {
36999 {
37000 arg3 = (int)(SWIG_As_int(obj2));
37001 if (SWIG_arg_fail(3)) SWIG_fail;
37002 }
37003 }
37004 if (obj3) {
37005 {
37006 arg4 = &temp4;
37007 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37008 }
37009 }
37010 if (obj4) {
37011 {
37012 arg5 = &temp5;
37013 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37014 }
37015 }
37016 if (obj5) {
37017 {
37018 arg6 = (long)(SWIG_As_long(obj5));
37019 if (SWIG_arg_fail(6)) SWIG_fail;
37020 }
37021 }
37022 if (obj6) {
37023 {
37024 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37025 if (SWIG_arg_fail(7)) SWIG_fail;
37026 if (arg7 == NULL) {
37027 SWIG_null_ref("wxValidator");
37028 }
37029 if (SWIG_arg_fail(7)) SWIG_fail;
37030 }
37031 }
37032 if (obj7) {
37033 {
37034 arg8 = wxString_in_helper(obj7);
37035 if (arg8 == NULL) SWIG_fail;
37036 temp8 = true;
37037 }
37038 }
37039 {
37040 PyThreadState* __tstate = wxPyBeginAllowThreads();
37041 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37042
37043 wxPyEndAllowThreads(__tstate);
37044 if (PyErr_Occurred()) SWIG_fail;
37045 }
37046 {
37047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37048 }
37049 {
37050 if (temp8)
37051 delete arg8;
37052 }
37053 return resultobj;
37054 fail:
37055 {
37056 if (temp8)
37057 delete arg8;
37058 }
37059 return NULL;
37060 }
37061
37062
37063 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37064 PyObject *resultobj;
37065 wxControl *arg1 = (wxControl *) 0 ;
37066 wxCommandEvent *arg2 = 0 ;
37067 PyObject * obj0 = 0 ;
37068 PyObject * obj1 = 0 ;
37069 char *kwnames[] = {
37070 (char *) "self",(char *) "event", NULL
37071 };
37072
37073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37075 if (SWIG_arg_fail(1)) SWIG_fail;
37076 {
37077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37078 if (SWIG_arg_fail(2)) SWIG_fail;
37079 if (arg2 == NULL) {
37080 SWIG_null_ref("wxCommandEvent");
37081 }
37082 if (SWIG_arg_fail(2)) SWIG_fail;
37083 }
37084 {
37085 PyThreadState* __tstate = wxPyBeginAllowThreads();
37086 (arg1)->Command(*arg2);
37087
37088 wxPyEndAllowThreads(__tstate);
37089 if (PyErr_Occurred()) SWIG_fail;
37090 }
37091 Py_INCREF(Py_None); resultobj = Py_None;
37092 return resultobj;
37093 fail:
37094 return NULL;
37095 }
37096
37097
37098 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37099 PyObject *resultobj;
37100 wxControl *arg1 = (wxControl *) 0 ;
37101 wxString result;
37102 PyObject * obj0 = 0 ;
37103 char *kwnames[] = {
37104 (char *) "self", NULL
37105 };
37106
37107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37109 if (SWIG_arg_fail(1)) SWIG_fail;
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 result = (arg1)->GetLabel();
37113
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 {
37118 #if wxUSE_UNICODE
37119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37120 #else
37121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37122 #endif
37123 }
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj;
37132 wxControl *arg1 = (wxControl *) 0 ;
37133 wxString *arg2 = 0 ;
37134 bool temp2 = false ;
37135 PyObject * obj0 = 0 ;
37136 PyObject * obj1 = 0 ;
37137 char *kwnames[] = {
37138 (char *) "self",(char *) "label", NULL
37139 };
37140
37141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37143 if (SWIG_arg_fail(1)) SWIG_fail;
37144 {
37145 arg2 = wxString_in_helper(obj1);
37146 if (arg2 == NULL) SWIG_fail;
37147 temp2 = true;
37148 }
37149 {
37150 PyThreadState* __tstate = wxPyBeginAllowThreads();
37151 (arg1)->SetLabel((wxString const &)*arg2);
37152
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 Py_INCREF(Py_None); resultobj = Py_None;
37157 {
37158 if (temp2)
37159 delete arg2;
37160 }
37161 return resultobj;
37162 fail:
37163 {
37164 if (temp2)
37165 delete arg2;
37166 }
37167 return NULL;
37168 }
37169
37170
37171 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37172 PyObject *resultobj;
37173 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37174 wxVisualAttributes result;
37175 PyObject * obj0 = 0 ;
37176 char *kwnames[] = {
37177 (char *) "variant", NULL
37178 };
37179
37180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37181 if (obj0) {
37182 {
37183 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37184 if (SWIG_arg_fail(1)) SWIG_fail;
37185 }
37186 }
37187 {
37188 if (!wxPyCheckForApp()) SWIG_fail;
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37191
37192 wxPyEndAllowThreads(__tstate);
37193 if (PyErr_Occurred()) SWIG_fail;
37194 }
37195 {
37196 wxVisualAttributes * resultptr;
37197 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37198 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37199 }
37200 return resultobj;
37201 fail:
37202 return NULL;
37203 }
37204
37205
37206 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37207 PyObject *obj;
37208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37209 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37210 Py_INCREF(obj);
37211 return Py_BuildValue((char *)"");
37212 }
37213 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj;
37215 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37216 wxString *arg2 = 0 ;
37217 PyObject *arg3 = (PyObject *) NULL ;
37218 int result;
37219 bool temp2 = false ;
37220 PyObject * obj0 = 0 ;
37221 PyObject * obj1 = 0 ;
37222 PyObject * obj2 = 0 ;
37223 char *kwnames[] = {
37224 (char *) "self",(char *) "item",(char *) "clientData", NULL
37225 };
37226
37227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37229 if (SWIG_arg_fail(1)) SWIG_fail;
37230 {
37231 arg2 = wxString_in_helper(obj1);
37232 if (arg2 == NULL) SWIG_fail;
37233 temp2 = true;
37234 }
37235 if (obj2) {
37236 arg3 = obj2;
37237 }
37238 {
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37241
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 {
37246 resultobj = SWIG_From_int((int)(result));
37247 }
37248 {
37249 if (temp2)
37250 delete arg2;
37251 }
37252 return resultobj;
37253 fail:
37254 {
37255 if (temp2)
37256 delete arg2;
37257 }
37258 return NULL;
37259 }
37260
37261
37262 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37263 PyObject *resultobj;
37264 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37265 wxArrayString *arg2 = 0 ;
37266 bool temp2 = false ;
37267 PyObject * obj0 = 0 ;
37268 PyObject * obj1 = 0 ;
37269 char *kwnames[] = {
37270 (char *) "self",(char *) "strings", NULL
37271 };
37272
37273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37275 if (SWIG_arg_fail(1)) SWIG_fail;
37276 {
37277 if (! PySequence_Check(obj1)) {
37278 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37279 SWIG_fail;
37280 }
37281 arg2 = new wxArrayString;
37282 temp2 = true;
37283 int i, len=PySequence_Length(obj1);
37284 for (i=0; i<len; i++) {
37285 PyObject* item = PySequence_GetItem(obj1, i);
37286 #if wxUSE_UNICODE
37287 PyObject* str = PyObject_Unicode(item);
37288 #else
37289 PyObject* str = PyObject_Str(item);
37290 #endif
37291 if (PyErr_Occurred()) SWIG_fail;
37292 arg2->Add(Py2wxString(str));
37293 Py_DECREF(item);
37294 Py_DECREF(str);
37295 }
37296 }
37297 {
37298 PyThreadState* __tstate = wxPyBeginAllowThreads();
37299 (arg1)->Append((wxArrayString const &)*arg2);
37300
37301 wxPyEndAllowThreads(__tstate);
37302 if (PyErr_Occurred()) SWIG_fail;
37303 }
37304 Py_INCREF(Py_None); resultobj = Py_None;
37305 {
37306 if (temp2) delete arg2;
37307 }
37308 return resultobj;
37309 fail:
37310 {
37311 if (temp2) delete arg2;
37312 }
37313 return NULL;
37314 }
37315
37316
37317 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37318 PyObject *resultobj;
37319 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37320 wxString *arg2 = 0 ;
37321 int arg3 ;
37322 PyObject *arg4 = (PyObject *) NULL ;
37323 int result;
37324 bool temp2 = false ;
37325 PyObject * obj0 = 0 ;
37326 PyObject * obj1 = 0 ;
37327 PyObject * obj2 = 0 ;
37328 PyObject * obj3 = 0 ;
37329 char *kwnames[] = {
37330 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37331 };
37332
37333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37335 if (SWIG_arg_fail(1)) SWIG_fail;
37336 {
37337 arg2 = wxString_in_helper(obj1);
37338 if (arg2 == NULL) SWIG_fail;
37339 temp2 = true;
37340 }
37341 {
37342 arg3 = (int)(SWIG_As_int(obj2));
37343 if (SWIG_arg_fail(3)) SWIG_fail;
37344 }
37345 if (obj3) {
37346 arg4 = obj3;
37347 }
37348 {
37349 PyThreadState* __tstate = wxPyBeginAllowThreads();
37350 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37351
37352 wxPyEndAllowThreads(__tstate);
37353 if (PyErr_Occurred()) SWIG_fail;
37354 }
37355 {
37356 resultobj = SWIG_From_int((int)(result));
37357 }
37358 {
37359 if (temp2)
37360 delete arg2;
37361 }
37362 return resultobj;
37363 fail:
37364 {
37365 if (temp2)
37366 delete arg2;
37367 }
37368 return NULL;
37369 }
37370
37371
37372 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37373 PyObject *resultobj;
37374 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37375 PyObject * obj0 = 0 ;
37376 char *kwnames[] = {
37377 (char *) "self", NULL
37378 };
37379
37380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37382 if (SWIG_arg_fail(1)) SWIG_fail;
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 (arg1)->Clear();
37386
37387 wxPyEndAllowThreads(__tstate);
37388 if (PyErr_Occurred()) SWIG_fail;
37389 }
37390 Py_INCREF(Py_None); resultobj = Py_None;
37391 return resultobj;
37392 fail:
37393 return NULL;
37394 }
37395
37396
37397 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37398 PyObject *resultobj;
37399 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37400 int arg2 ;
37401 PyObject * obj0 = 0 ;
37402 PyObject * obj1 = 0 ;
37403 char *kwnames[] = {
37404 (char *) "self",(char *) "n", NULL
37405 };
37406
37407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37409 if (SWIG_arg_fail(1)) SWIG_fail;
37410 {
37411 arg2 = (int)(SWIG_As_int(obj1));
37412 if (SWIG_arg_fail(2)) SWIG_fail;
37413 }
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 (arg1)->Delete(arg2);
37417
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 Py_INCREF(Py_None); resultobj = Py_None;
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37429 PyObject *resultobj;
37430 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37431 int arg2 ;
37432 PyObject *result;
37433 PyObject * obj0 = 0 ;
37434 PyObject * obj1 = 0 ;
37435 char *kwnames[] = {
37436 (char *) "self",(char *) "n", NULL
37437 };
37438
37439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37441 if (SWIG_arg_fail(1)) SWIG_fail;
37442 {
37443 arg2 = (int)(SWIG_As_int(obj1));
37444 if (SWIG_arg_fail(2)) SWIG_fail;
37445 }
37446 {
37447 PyThreadState* __tstate = wxPyBeginAllowThreads();
37448 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37449
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 resultobj = result;
37454 return resultobj;
37455 fail:
37456 return NULL;
37457 }
37458
37459
37460 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37461 PyObject *resultobj;
37462 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37463 int arg2 ;
37464 PyObject *arg3 = (PyObject *) 0 ;
37465 PyObject * obj0 = 0 ;
37466 PyObject * obj1 = 0 ;
37467 PyObject * obj2 = 0 ;
37468 char *kwnames[] = {
37469 (char *) "self",(char *) "n",(char *) "clientData", NULL
37470 };
37471
37472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37474 if (SWIG_arg_fail(1)) SWIG_fail;
37475 {
37476 arg2 = (int)(SWIG_As_int(obj1));
37477 if (SWIG_arg_fail(2)) SWIG_fail;
37478 }
37479 arg3 = obj2;
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 wxItemContainer_SetClientData(arg1,arg2,arg3);
37483
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 Py_INCREF(Py_None); resultobj = Py_None;
37488 return resultobj;
37489 fail:
37490 return NULL;
37491 }
37492
37493
37494 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37495 PyObject *resultobj;
37496 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37497 int result;
37498 PyObject * obj0 = 0 ;
37499 char *kwnames[] = {
37500 (char *) "self", NULL
37501 };
37502
37503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37505 if (SWIG_arg_fail(1)) SWIG_fail;
37506 {
37507 PyThreadState* __tstate = wxPyBeginAllowThreads();
37508 result = (int)((wxItemContainer const *)arg1)->GetCount();
37509
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 {
37514 resultobj = SWIG_From_int((int)(result));
37515 }
37516 return resultobj;
37517 fail:
37518 return NULL;
37519 }
37520
37521
37522 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37523 PyObject *resultobj;
37524 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37525 bool result;
37526 PyObject * obj0 = 0 ;
37527 char *kwnames[] = {
37528 (char *) "self", NULL
37529 };
37530
37531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37533 if (SWIG_arg_fail(1)) SWIG_fail;
37534 {
37535 PyThreadState* __tstate = wxPyBeginAllowThreads();
37536 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37537
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 {
37542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37543 }
37544 return resultobj;
37545 fail:
37546 return NULL;
37547 }
37548
37549
37550 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37551 PyObject *resultobj;
37552 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37553 int arg2 ;
37554 wxString result;
37555 PyObject * obj0 = 0 ;
37556 PyObject * obj1 = 0 ;
37557 char *kwnames[] = {
37558 (char *) "self",(char *) "n", NULL
37559 };
37560
37561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37563 if (SWIG_arg_fail(1)) SWIG_fail;
37564 {
37565 arg2 = (int)(SWIG_As_int(obj1));
37566 if (SWIG_arg_fail(2)) SWIG_fail;
37567 }
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37571
37572 wxPyEndAllowThreads(__tstate);
37573 if (PyErr_Occurred()) SWIG_fail;
37574 }
37575 {
37576 #if wxUSE_UNICODE
37577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37578 #else
37579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37580 #endif
37581 }
37582 return resultobj;
37583 fail:
37584 return NULL;
37585 }
37586
37587
37588 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37589 PyObject *resultobj;
37590 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37591 wxArrayString result;
37592 PyObject * obj0 = 0 ;
37593 char *kwnames[] = {
37594 (char *) "self", NULL
37595 };
37596
37597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37599 if (SWIG_arg_fail(1)) SWIG_fail;
37600 {
37601 PyThreadState* __tstate = wxPyBeginAllowThreads();
37602 result = ((wxItemContainer const *)arg1)->GetStrings();
37603
37604 wxPyEndAllowThreads(__tstate);
37605 if (PyErr_Occurred()) SWIG_fail;
37606 }
37607 {
37608 resultobj = wxArrayString2PyList_helper(result);
37609 }
37610 return resultobj;
37611 fail:
37612 return NULL;
37613 }
37614
37615
37616 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37617 PyObject *resultobj;
37618 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37619 int arg2 ;
37620 wxString *arg3 = 0 ;
37621 bool temp3 = false ;
37622 PyObject * obj0 = 0 ;
37623 PyObject * obj1 = 0 ;
37624 PyObject * obj2 = 0 ;
37625 char *kwnames[] = {
37626 (char *) "self",(char *) "n",(char *) "s", NULL
37627 };
37628
37629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37631 if (SWIG_arg_fail(1)) SWIG_fail;
37632 {
37633 arg2 = (int)(SWIG_As_int(obj1));
37634 if (SWIG_arg_fail(2)) SWIG_fail;
37635 }
37636 {
37637 arg3 = wxString_in_helper(obj2);
37638 if (arg3 == NULL) SWIG_fail;
37639 temp3 = true;
37640 }
37641 {
37642 PyThreadState* __tstate = wxPyBeginAllowThreads();
37643 (arg1)->SetString(arg2,(wxString const &)*arg3);
37644
37645 wxPyEndAllowThreads(__tstate);
37646 if (PyErr_Occurred()) SWIG_fail;
37647 }
37648 Py_INCREF(Py_None); resultobj = Py_None;
37649 {
37650 if (temp3)
37651 delete arg3;
37652 }
37653 return resultobj;
37654 fail:
37655 {
37656 if (temp3)
37657 delete arg3;
37658 }
37659 return NULL;
37660 }
37661
37662
37663 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37664 PyObject *resultobj;
37665 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37666 wxString *arg2 = 0 ;
37667 int result;
37668 bool temp2 = false ;
37669 PyObject * obj0 = 0 ;
37670 PyObject * obj1 = 0 ;
37671 char *kwnames[] = {
37672 (char *) "self",(char *) "s", NULL
37673 };
37674
37675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37677 if (SWIG_arg_fail(1)) SWIG_fail;
37678 {
37679 arg2 = wxString_in_helper(obj1);
37680 if (arg2 == NULL) SWIG_fail;
37681 temp2 = true;
37682 }
37683 {
37684 PyThreadState* __tstate = wxPyBeginAllowThreads();
37685 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37686
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 {
37691 resultobj = SWIG_From_int((int)(result));
37692 }
37693 {
37694 if (temp2)
37695 delete arg2;
37696 }
37697 return resultobj;
37698 fail:
37699 {
37700 if (temp2)
37701 delete arg2;
37702 }
37703 return NULL;
37704 }
37705
37706
37707 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37708 PyObject *resultobj;
37709 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37710 int arg2 ;
37711 PyObject * obj0 = 0 ;
37712 PyObject * obj1 = 0 ;
37713 char *kwnames[] = {
37714 (char *) "self",(char *) "n", NULL
37715 };
37716
37717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37719 if (SWIG_arg_fail(1)) SWIG_fail;
37720 {
37721 arg2 = (int)(SWIG_As_int(obj1));
37722 if (SWIG_arg_fail(2)) SWIG_fail;
37723 }
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 (arg1)->SetSelection(arg2);
37727
37728 wxPyEndAllowThreads(__tstate);
37729 if (PyErr_Occurred()) SWIG_fail;
37730 }
37731 Py_INCREF(Py_None); resultobj = Py_None;
37732 return resultobj;
37733 fail:
37734 return NULL;
37735 }
37736
37737
37738 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37739 PyObject *resultobj;
37740 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37741 int result;
37742 PyObject * obj0 = 0 ;
37743 char *kwnames[] = {
37744 (char *) "self", NULL
37745 };
37746
37747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37749 if (SWIG_arg_fail(1)) SWIG_fail;
37750 {
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37753
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 resultobj = SWIG_From_int((int)(result));
37759 }
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj;
37768 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37769 wxString *arg2 = 0 ;
37770 bool result;
37771 bool temp2 = false ;
37772 PyObject * obj0 = 0 ;
37773 PyObject * obj1 = 0 ;
37774 char *kwnames[] = {
37775 (char *) "self",(char *) "s", NULL
37776 };
37777
37778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37780 if (SWIG_arg_fail(1)) SWIG_fail;
37781 {
37782 arg2 = wxString_in_helper(obj1);
37783 if (arg2 == NULL) SWIG_fail;
37784 temp2 = true;
37785 }
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37789
37790 wxPyEndAllowThreads(__tstate);
37791 if (PyErr_Occurred()) SWIG_fail;
37792 }
37793 {
37794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37795 }
37796 {
37797 if (temp2)
37798 delete arg2;
37799 }
37800 return resultobj;
37801 fail:
37802 {
37803 if (temp2)
37804 delete arg2;
37805 }
37806 return NULL;
37807 }
37808
37809
37810 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37811 PyObject *resultobj;
37812 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37813 wxString result;
37814 PyObject * obj0 = 0 ;
37815 char *kwnames[] = {
37816 (char *) "self", NULL
37817 };
37818
37819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37821 if (SWIG_arg_fail(1)) SWIG_fail;
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37825
37826 wxPyEndAllowThreads(__tstate);
37827 if (PyErr_Occurred()) SWIG_fail;
37828 }
37829 {
37830 #if wxUSE_UNICODE
37831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37832 #else
37833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37834 #endif
37835 }
37836 return resultobj;
37837 fail:
37838 return NULL;
37839 }
37840
37841
37842 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37843 PyObject *resultobj;
37844 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37845 int arg2 ;
37846 PyObject * obj0 = 0 ;
37847 PyObject * obj1 = 0 ;
37848 char *kwnames[] = {
37849 (char *) "self",(char *) "n", NULL
37850 };
37851
37852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37854 if (SWIG_arg_fail(1)) SWIG_fail;
37855 {
37856 arg2 = (int)(SWIG_As_int(obj1));
37857 if (SWIG_arg_fail(2)) SWIG_fail;
37858 }
37859 {
37860 PyThreadState* __tstate = wxPyBeginAllowThreads();
37861 (arg1)->Select(arg2);
37862
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 Py_INCREF(Py_None); resultobj = Py_None;
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37874 PyObject *obj;
37875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37876 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37877 Py_INCREF(obj);
37878 return Py_BuildValue((char *)"");
37879 }
37880 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37881 PyObject *obj;
37882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37883 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37884 Py_INCREF(obj);
37885 return Py_BuildValue((char *)"");
37886 }
37887 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37888 PyObject *resultobj;
37889 wxSizerItem *result;
37890 char *kwnames[] = {
37891 NULL
37892 };
37893
37894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 result = (wxSizerItem *)new wxSizerItem();
37898
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37910 PyObject *resultobj;
37911 wxWindow *arg1 = (wxWindow *) 0 ;
37912 int arg2 ;
37913 int arg3 ;
37914 int arg4 ;
37915 PyObject *arg5 = (PyObject *) NULL ;
37916 wxSizerItem *result;
37917 PyObject * obj0 = 0 ;
37918 PyObject * obj1 = 0 ;
37919 PyObject * obj2 = 0 ;
37920 PyObject * obj3 = 0 ;
37921 PyObject * obj4 = 0 ;
37922 char *kwnames[] = {
37923 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37924 };
37925
37926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, 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 arg3 = (int)(SWIG_As_int(obj2));
37935 if (SWIG_arg_fail(3)) SWIG_fail;
37936 }
37937 {
37938 arg4 = (int)(SWIG_As_int(obj3));
37939 if (SWIG_arg_fail(4)) SWIG_fail;
37940 }
37941 if (obj4) {
37942 arg5 = obj4;
37943 }
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37947
37948 wxPyEndAllowThreads(__tstate);
37949 if (PyErr_Occurred()) SWIG_fail;
37950 }
37951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37952 return resultobj;
37953 fail:
37954 return NULL;
37955 }
37956
37957
37958 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37959 PyObject *resultobj;
37960 int arg1 ;
37961 int arg2 ;
37962 int arg3 ;
37963 int arg4 ;
37964 int arg5 ;
37965 PyObject *arg6 = (PyObject *) NULL ;
37966 wxSizerItem *result;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 PyObject * obj2 = 0 ;
37970 PyObject * obj3 = 0 ;
37971 PyObject * obj4 = 0 ;
37972 PyObject * obj5 = 0 ;
37973 char *kwnames[] = {
37974 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37975 };
37976
37977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37978 {
37979 arg1 = (int)(SWIG_As_int(obj0));
37980 if (SWIG_arg_fail(1)) SWIG_fail;
37981 }
37982 {
37983 arg2 = (int)(SWIG_As_int(obj1));
37984 if (SWIG_arg_fail(2)) SWIG_fail;
37985 }
37986 {
37987 arg3 = (int)(SWIG_As_int(obj2));
37988 if (SWIG_arg_fail(3)) SWIG_fail;
37989 }
37990 {
37991 arg4 = (int)(SWIG_As_int(obj3));
37992 if (SWIG_arg_fail(4)) SWIG_fail;
37993 }
37994 {
37995 arg5 = (int)(SWIG_As_int(obj4));
37996 if (SWIG_arg_fail(5)) SWIG_fail;
37997 }
37998 if (obj5) {
37999 arg6 = obj5;
38000 }
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38004
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38016 PyObject *resultobj;
38017 wxSizer *arg1 = (wxSizer *) 0 ;
38018 int arg2 ;
38019 int arg3 ;
38020 int arg4 ;
38021 PyObject *arg5 = (PyObject *) NULL ;
38022 wxSizerItem *result;
38023 PyObject * obj0 = 0 ;
38024 PyObject * obj1 = 0 ;
38025 PyObject * obj2 = 0 ;
38026 PyObject * obj3 = 0 ;
38027 PyObject * obj4 = 0 ;
38028 char *kwnames[] = {
38029 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38030 };
38031
38032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38034 if (SWIG_arg_fail(1)) SWIG_fail;
38035 {
38036 arg2 = (int)(SWIG_As_int(obj1));
38037 if (SWIG_arg_fail(2)) SWIG_fail;
38038 }
38039 {
38040 arg3 = (int)(SWIG_As_int(obj2));
38041 if (SWIG_arg_fail(3)) SWIG_fail;
38042 }
38043 {
38044 arg4 = (int)(SWIG_As_int(obj3));
38045 if (SWIG_arg_fail(4)) SWIG_fail;
38046 }
38047 if (obj4) {
38048 arg5 = obj4;
38049 }
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38053
38054 wxPyEndAllowThreads(__tstate);
38055 if (PyErr_Occurred()) SWIG_fail;
38056 }
38057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38058 return resultobj;
38059 fail:
38060 return NULL;
38061 }
38062
38063
38064 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38065 PyObject *resultobj;
38066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38067 PyObject * obj0 = 0 ;
38068 char *kwnames[] = {
38069 (char *) "self", NULL
38070 };
38071
38072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38074 if (SWIG_arg_fail(1)) SWIG_fail;
38075 {
38076 PyThreadState* __tstate = wxPyBeginAllowThreads();
38077 (arg1)->DeleteWindows();
38078
38079 wxPyEndAllowThreads(__tstate);
38080 if (PyErr_Occurred()) SWIG_fail;
38081 }
38082 Py_INCREF(Py_None); resultobj = Py_None;
38083 return resultobj;
38084 fail:
38085 return NULL;
38086 }
38087
38088
38089 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38090 PyObject *resultobj;
38091 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38092 PyObject * obj0 = 0 ;
38093 char *kwnames[] = {
38094 (char *) "self", NULL
38095 };
38096
38097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38099 if (SWIG_arg_fail(1)) SWIG_fail;
38100 {
38101 PyThreadState* __tstate = wxPyBeginAllowThreads();
38102 (arg1)->DetachSizer();
38103
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 Py_INCREF(Py_None); resultobj = Py_None;
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38115 PyObject *resultobj;
38116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38117 wxSize result;
38118 PyObject * obj0 = 0 ;
38119 char *kwnames[] = {
38120 (char *) "self", NULL
38121 };
38122
38123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38125 if (SWIG_arg_fail(1)) SWIG_fail;
38126 {
38127 PyThreadState* __tstate = wxPyBeginAllowThreads();
38128 result = (arg1)->GetSize();
38129
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 {
38134 wxSize * resultptr;
38135 resultptr = new wxSize((wxSize &)(result));
38136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38137 }
38138 return resultobj;
38139 fail:
38140 return NULL;
38141 }
38142
38143
38144 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38145 PyObject *resultobj;
38146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38147 wxSize result;
38148 PyObject * obj0 = 0 ;
38149 char *kwnames[] = {
38150 (char *) "self", NULL
38151 };
38152
38153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38155 if (SWIG_arg_fail(1)) SWIG_fail;
38156 {
38157 PyThreadState* __tstate = wxPyBeginAllowThreads();
38158 result = (arg1)->CalcMin();
38159
38160 wxPyEndAllowThreads(__tstate);
38161 if (PyErr_Occurred()) SWIG_fail;
38162 }
38163 {
38164 wxSize * resultptr;
38165 resultptr = new wxSize((wxSize &)(result));
38166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38167 }
38168 return resultobj;
38169 fail:
38170 return NULL;
38171 }
38172
38173
38174 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38175 PyObject *resultobj;
38176 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38177 wxPoint arg2 ;
38178 wxSize arg3 ;
38179 PyObject * obj0 = 0 ;
38180 PyObject * obj1 = 0 ;
38181 PyObject * obj2 = 0 ;
38182 char *kwnames[] = {
38183 (char *) "self",(char *) "pos",(char *) "size", NULL
38184 };
38185
38186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38188 if (SWIG_arg_fail(1)) SWIG_fail;
38189 {
38190 wxPoint * argp;
38191 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38192 if (SWIG_arg_fail(2)) SWIG_fail;
38193 if (argp == NULL) {
38194 SWIG_null_ref("wxPoint");
38195 }
38196 if (SWIG_arg_fail(2)) SWIG_fail;
38197 arg2 = *argp;
38198 }
38199 {
38200 wxSize * argp;
38201 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38202 if (SWIG_arg_fail(3)) SWIG_fail;
38203 if (argp == NULL) {
38204 SWIG_null_ref("wxSize");
38205 }
38206 if (SWIG_arg_fail(3)) SWIG_fail;
38207 arg3 = *argp;
38208 }
38209 {
38210 PyThreadState* __tstate = wxPyBeginAllowThreads();
38211 (arg1)->SetDimension(arg2,arg3);
38212
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 Py_INCREF(Py_None); resultobj = Py_None;
38217 return resultobj;
38218 fail:
38219 return NULL;
38220 }
38221
38222
38223 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38224 PyObject *resultobj;
38225 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38226 wxSize result;
38227 PyObject * obj0 = 0 ;
38228 char *kwnames[] = {
38229 (char *) "self", NULL
38230 };
38231
38232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38234 if (SWIG_arg_fail(1)) SWIG_fail;
38235 {
38236 PyThreadState* __tstate = wxPyBeginAllowThreads();
38237 result = (arg1)->GetMinSize();
38238
38239 wxPyEndAllowThreads(__tstate);
38240 if (PyErr_Occurred()) SWIG_fail;
38241 }
38242 {
38243 wxSize * resultptr;
38244 resultptr = new wxSize((wxSize &)(result));
38245 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38246 }
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj;
38255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38256 wxSize result;
38257 PyObject * obj0 = 0 ;
38258 char *kwnames[] = {
38259 (char *) "self", NULL
38260 };
38261
38262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38264 if (SWIG_arg_fail(1)) SWIG_fail;
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38268
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 {
38273 wxSize * resultptr;
38274 resultptr = new wxSize((wxSize &)(result));
38275 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38276 }
38277 return resultobj;
38278 fail:
38279 return NULL;
38280 }
38281
38282
38283 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38284 PyObject *resultobj;
38285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38286 int arg2 ;
38287 int arg3 ;
38288 PyObject * obj0 = 0 ;
38289 PyObject * obj1 = 0 ;
38290 PyObject * obj2 = 0 ;
38291 char *kwnames[] = {
38292 (char *) "self",(char *) "x",(char *) "y", NULL
38293 };
38294
38295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38297 if (SWIG_arg_fail(1)) SWIG_fail;
38298 {
38299 arg2 = (int)(SWIG_As_int(obj1));
38300 if (SWIG_arg_fail(2)) SWIG_fail;
38301 }
38302 {
38303 arg3 = (int)(SWIG_As_int(obj2));
38304 if (SWIG_arg_fail(3)) SWIG_fail;
38305 }
38306 {
38307 PyThreadState* __tstate = wxPyBeginAllowThreads();
38308 (arg1)->SetInitSize(arg2,arg3);
38309
38310 wxPyEndAllowThreads(__tstate);
38311 if (PyErr_Occurred()) SWIG_fail;
38312 }
38313 Py_INCREF(Py_None); resultobj = Py_None;
38314 return resultobj;
38315 fail:
38316 return NULL;
38317 }
38318
38319
38320 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38321 PyObject *resultobj;
38322 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38323 int arg2 ;
38324 int arg3 ;
38325 PyObject * obj0 = 0 ;
38326 PyObject * obj1 = 0 ;
38327 PyObject * obj2 = 0 ;
38328 char *kwnames[] = {
38329 (char *) "self",(char *) "width",(char *) "height", NULL
38330 };
38331
38332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38334 if (SWIG_arg_fail(1)) SWIG_fail;
38335 {
38336 arg2 = (int)(SWIG_As_int(obj1));
38337 if (SWIG_arg_fail(2)) SWIG_fail;
38338 }
38339 {
38340 arg3 = (int)(SWIG_As_int(obj2));
38341 if (SWIG_arg_fail(3)) SWIG_fail;
38342 }
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 (arg1)->SetRatio(arg2,arg3);
38346
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 Py_INCREF(Py_None); resultobj = Py_None;
38351 return resultobj;
38352 fail:
38353 return NULL;
38354 }
38355
38356
38357 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38358 PyObject *resultobj;
38359 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38360 wxSize arg2 ;
38361 PyObject * obj0 = 0 ;
38362 PyObject * obj1 = 0 ;
38363 char *kwnames[] = {
38364 (char *) "self",(char *) "size", NULL
38365 };
38366
38367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38369 if (SWIG_arg_fail(1)) SWIG_fail;
38370 {
38371 wxSize * argp;
38372 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38373 if (SWIG_arg_fail(2)) SWIG_fail;
38374 if (argp == NULL) {
38375 SWIG_null_ref("wxSize");
38376 }
38377 if (SWIG_arg_fail(2)) SWIG_fail;
38378 arg2 = *argp;
38379 }
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 (arg1)->SetRatio(arg2);
38383
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 Py_INCREF(Py_None); resultobj = Py_None;
38388 return resultobj;
38389 fail:
38390 return NULL;
38391 }
38392
38393
38394 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38395 PyObject *resultobj;
38396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38397 float arg2 ;
38398 PyObject * obj0 = 0 ;
38399 PyObject * obj1 = 0 ;
38400 char *kwnames[] = {
38401 (char *) "self",(char *) "ratio", NULL
38402 };
38403
38404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38406 if (SWIG_arg_fail(1)) SWIG_fail;
38407 {
38408 arg2 = (float)(SWIG_As_float(obj1));
38409 if (SWIG_arg_fail(2)) SWIG_fail;
38410 }
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 (arg1)->SetRatio(arg2);
38414
38415 wxPyEndAllowThreads(__tstate);
38416 if (PyErr_Occurred()) SWIG_fail;
38417 }
38418 Py_INCREF(Py_None); resultobj = Py_None;
38419 return resultobj;
38420 fail:
38421 return NULL;
38422 }
38423
38424
38425 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38426 PyObject *resultobj;
38427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38428 float result;
38429 PyObject * obj0 = 0 ;
38430 char *kwnames[] = {
38431 (char *) "self", NULL
38432 };
38433
38434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38436 if (SWIG_arg_fail(1)) SWIG_fail;
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (float)(arg1)->GetRatio();
38440
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 {
38445 resultobj = SWIG_From_float((float)(result));
38446 }
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj;
38455 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38456 wxRect result;
38457 PyObject * obj0 = 0 ;
38458 char *kwnames[] = {
38459 (char *) "self", NULL
38460 };
38461
38462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38464 if (SWIG_arg_fail(1)) SWIG_fail;
38465 {
38466 PyThreadState* __tstate = wxPyBeginAllowThreads();
38467 result = (arg1)->GetRect();
38468
38469 wxPyEndAllowThreads(__tstate);
38470 if (PyErr_Occurred()) SWIG_fail;
38471 }
38472 {
38473 wxRect * resultptr;
38474 resultptr = new wxRect((wxRect &)(result));
38475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38476 }
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38484 PyObject *resultobj;
38485 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38486 bool result;
38487 PyObject * obj0 = 0 ;
38488 char *kwnames[] = {
38489 (char *) "self", NULL
38490 };
38491
38492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38494 if (SWIG_arg_fail(1)) SWIG_fail;
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 result = (bool)(arg1)->IsWindow();
38498
38499 wxPyEndAllowThreads(__tstate);
38500 if (PyErr_Occurred()) SWIG_fail;
38501 }
38502 {
38503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38504 }
38505 return resultobj;
38506 fail:
38507 return NULL;
38508 }
38509
38510
38511 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38512 PyObject *resultobj;
38513 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38514 bool result;
38515 PyObject * obj0 = 0 ;
38516 char *kwnames[] = {
38517 (char *) "self", NULL
38518 };
38519
38520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38522 if (SWIG_arg_fail(1)) SWIG_fail;
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (bool)(arg1)->IsSizer();
38526
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 {
38531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38532 }
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38540 PyObject *resultobj;
38541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38542 bool result;
38543 PyObject * obj0 = 0 ;
38544 char *kwnames[] = {
38545 (char *) "self", NULL
38546 };
38547
38548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38550 if (SWIG_arg_fail(1)) SWIG_fail;
38551 {
38552 PyThreadState* __tstate = wxPyBeginAllowThreads();
38553 result = (bool)(arg1)->IsSpacer();
38554
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 {
38559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38560 }
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38568 PyObject *resultobj;
38569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38570 int arg2 ;
38571 PyObject * obj0 = 0 ;
38572 PyObject * obj1 = 0 ;
38573 char *kwnames[] = {
38574 (char *) "self",(char *) "proportion", NULL
38575 };
38576
38577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38579 if (SWIG_arg_fail(1)) SWIG_fail;
38580 {
38581 arg2 = (int)(SWIG_As_int(obj1));
38582 if (SWIG_arg_fail(2)) SWIG_fail;
38583 }
38584 {
38585 PyThreadState* __tstate = wxPyBeginAllowThreads();
38586 (arg1)->SetProportion(arg2);
38587
38588 wxPyEndAllowThreads(__tstate);
38589 if (PyErr_Occurred()) SWIG_fail;
38590 }
38591 Py_INCREF(Py_None); resultobj = Py_None;
38592 return resultobj;
38593 fail:
38594 return NULL;
38595 }
38596
38597
38598 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38599 PyObject *resultobj;
38600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38601 int result;
38602 PyObject * obj0 = 0 ;
38603 char *kwnames[] = {
38604 (char *) "self", NULL
38605 };
38606
38607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38609 if (SWIG_arg_fail(1)) SWIG_fail;
38610 {
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 result = (int)(arg1)->GetProportion();
38613
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 resultobj = SWIG_From_int((int)(result));
38619 }
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj;
38628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38629 int arg2 ;
38630 PyObject * obj0 = 0 ;
38631 PyObject * obj1 = 0 ;
38632 char *kwnames[] = {
38633 (char *) "self",(char *) "flag", NULL
38634 };
38635
38636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38638 if (SWIG_arg_fail(1)) SWIG_fail;
38639 {
38640 arg2 = (int)(SWIG_As_int(obj1));
38641 if (SWIG_arg_fail(2)) SWIG_fail;
38642 }
38643 {
38644 PyThreadState* __tstate = wxPyBeginAllowThreads();
38645 (arg1)->SetFlag(arg2);
38646
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 Py_INCREF(Py_None); resultobj = Py_None;
38651 return resultobj;
38652 fail:
38653 return NULL;
38654 }
38655
38656
38657 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38658 PyObject *resultobj;
38659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38660 int result;
38661 PyObject * obj0 = 0 ;
38662 char *kwnames[] = {
38663 (char *) "self", NULL
38664 };
38665
38666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38668 if (SWIG_arg_fail(1)) SWIG_fail;
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = (int)(arg1)->GetFlag();
38672
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 {
38677 resultobj = SWIG_From_int((int)(result));
38678 }
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38686 PyObject *resultobj;
38687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38688 int arg2 ;
38689 PyObject * obj0 = 0 ;
38690 PyObject * obj1 = 0 ;
38691 char *kwnames[] = {
38692 (char *) "self",(char *) "border", NULL
38693 };
38694
38695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38697 if (SWIG_arg_fail(1)) SWIG_fail;
38698 {
38699 arg2 = (int)(SWIG_As_int(obj1));
38700 if (SWIG_arg_fail(2)) SWIG_fail;
38701 }
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 (arg1)->SetBorder(arg2);
38705
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 Py_INCREF(Py_None); resultobj = Py_None;
38710 return resultobj;
38711 fail:
38712 return NULL;
38713 }
38714
38715
38716 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38717 PyObject *resultobj;
38718 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38719 int result;
38720 PyObject * obj0 = 0 ;
38721 char *kwnames[] = {
38722 (char *) "self", NULL
38723 };
38724
38725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38727 if (SWIG_arg_fail(1)) SWIG_fail;
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = (int)(arg1)->GetBorder();
38731
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = SWIG_From_int((int)(result));
38737 }
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj;
38746 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38747 wxWindow *result;
38748 PyObject * obj0 = 0 ;
38749 char *kwnames[] = {
38750 (char *) "self", NULL
38751 };
38752
38753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38755 if (SWIG_arg_fail(1)) SWIG_fail;
38756 {
38757 PyThreadState* __tstate = wxPyBeginAllowThreads();
38758 result = (wxWindow *)(arg1)->GetWindow();
38759
38760 wxPyEndAllowThreads(__tstate);
38761 if (PyErr_Occurred()) SWIG_fail;
38762 }
38763 {
38764 resultobj = wxPyMake_wxObject(result, 0);
38765 }
38766 return resultobj;
38767 fail:
38768 return NULL;
38769 }
38770
38771
38772 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38773 PyObject *resultobj;
38774 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38775 wxWindow *arg2 = (wxWindow *) 0 ;
38776 PyObject * obj0 = 0 ;
38777 PyObject * obj1 = 0 ;
38778 char *kwnames[] = {
38779 (char *) "self",(char *) "window", NULL
38780 };
38781
38782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38786 if (SWIG_arg_fail(2)) SWIG_fail;
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 (arg1)->SetWindow(arg2);
38790
38791 wxPyEndAllowThreads(__tstate);
38792 if (PyErr_Occurred()) SWIG_fail;
38793 }
38794 Py_INCREF(Py_None); resultobj = Py_None;
38795 return resultobj;
38796 fail:
38797 return NULL;
38798 }
38799
38800
38801 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38802 PyObject *resultobj;
38803 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38804 wxSizer *result;
38805 PyObject * obj0 = 0 ;
38806 char *kwnames[] = {
38807 (char *) "self", NULL
38808 };
38809
38810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38812 if (SWIG_arg_fail(1)) SWIG_fail;
38813 {
38814 PyThreadState* __tstate = wxPyBeginAllowThreads();
38815 result = (wxSizer *)(arg1)->GetSizer();
38816
38817 wxPyEndAllowThreads(__tstate);
38818 if (PyErr_Occurred()) SWIG_fail;
38819 }
38820 {
38821 resultobj = wxPyMake_wxSizer(result, 0);
38822 }
38823 return resultobj;
38824 fail:
38825 return NULL;
38826 }
38827
38828
38829 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38830 PyObject *resultobj;
38831 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38832 wxSizer *arg2 = (wxSizer *) 0 ;
38833 PyObject * obj0 = 0 ;
38834 PyObject * obj1 = 0 ;
38835 char *kwnames[] = {
38836 (char *) "self",(char *) "sizer", NULL
38837 };
38838
38839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38841 if (SWIG_arg_fail(1)) SWIG_fail;
38842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38843 if (SWIG_arg_fail(2)) SWIG_fail;
38844 {
38845 PyThreadState* __tstate = wxPyBeginAllowThreads();
38846 (arg1)->SetSizer(arg2);
38847
38848 wxPyEndAllowThreads(__tstate);
38849 if (PyErr_Occurred()) SWIG_fail;
38850 }
38851 Py_INCREF(Py_None); resultobj = Py_None;
38852 return resultobj;
38853 fail:
38854 return NULL;
38855 }
38856
38857
38858 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38859 PyObject *resultobj;
38860 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38861 wxSize *result;
38862 PyObject * obj0 = 0 ;
38863 char *kwnames[] = {
38864 (char *) "self", NULL
38865 };
38866
38867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38869 if (SWIG_arg_fail(1)) SWIG_fail;
38870 {
38871 PyThreadState* __tstate = wxPyBeginAllowThreads();
38872 {
38873 wxSize const &_result_ref = (arg1)->GetSpacer();
38874 result = (wxSize *) &_result_ref;
38875 }
38876
38877 wxPyEndAllowThreads(__tstate);
38878 if (PyErr_Occurred()) SWIG_fail;
38879 }
38880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38888 PyObject *resultobj;
38889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38890 wxSize *arg2 = 0 ;
38891 wxSize temp2 ;
38892 PyObject * obj0 = 0 ;
38893 PyObject * obj1 = 0 ;
38894 char *kwnames[] = {
38895 (char *) "self",(char *) "size", NULL
38896 };
38897
38898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38900 if (SWIG_arg_fail(1)) SWIG_fail;
38901 {
38902 arg2 = &temp2;
38903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38904 }
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 (arg1)->SetSpacer((wxSize const &)*arg2);
38908
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 Py_INCREF(Py_None); resultobj = Py_None;
38913 return resultobj;
38914 fail:
38915 return NULL;
38916 }
38917
38918
38919 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38920 PyObject *resultobj;
38921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38922 bool arg2 ;
38923 PyObject * obj0 = 0 ;
38924 PyObject * obj1 = 0 ;
38925 char *kwnames[] = {
38926 (char *) "self",(char *) "show", NULL
38927 };
38928
38929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38931 if (SWIG_arg_fail(1)) SWIG_fail;
38932 {
38933 arg2 = (bool)(SWIG_As_bool(obj1));
38934 if (SWIG_arg_fail(2)) SWIG_fail;
38935 }
38936 {
38937 PyThreadState* __tstate = wxPyBeginAllowThreads();
38938 (arg1)->Show(arg2);
38939
38940 wxPyEndAllowThreads(__tstate);
38941 if (PyErr_Occurred()) SWIG_fail;
38942 }
38943 Py_INCREF(Py_None); resultobj = Py_None;
38944 return resultobj;
38945 fail:
38946 return NULL;
38947 }
38948
38949
38950 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38951 PyObject *resultobj;
38952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38953 bool result;
38954 PyObject * obj0 = 0 ;
38955 char *kwnames[] = {
38956 (char *) "self", NULL
38957 };
38958
38959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38961 if (SWIG_arg_fail(1)) SWIG_fail;
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 result = (bool)(arg1)->IsShown();
38965
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 {
38970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38971 }
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38979 PyObject *resultobj;
38980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38981 wxPoint result;
38982 PyObject * obj0 = 0 ;
38983 char *kwnames[] = {
38984 (char *) "self", NULL
38985 };
38986
38987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38989 if (SWIG_arg_fail(1)) SWIG_fail;
38990 {
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (arg1)->GetPosition();
38993
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 wxPoint * resultptr;
38999 resultptr = new wxPoint((wxPoint &)(result));
39000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39001 }
39002 return resultobj;
39003 fail:
39004 return NULL;
39005 }
39006
39007
39008 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj;
39010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39011 PyObject *result;
39012 PyObject * obj0 = 0 ;
39013 char *kwnames[] = {
39014 (char *) "self", NULL
39015 };
39016
39017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39019 if (SWIG_arg_fail(1)) SWIG_fail;
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39023
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 resultobj = result;
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39035 PyObject *obj;
39036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39037 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39038 Py_INCREF(obj);
39039 return Py_BuildValue((char *)"");
39040 }
39041 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39042 PyObject *resultobj;
39043 wxSizer *arg1 = (wxSizer *) 0 ;
39044 PyObject *arg2 = (PyObject *) 0 ;
39045 PyObject * obj0 = 0 ;
39046 PyObject * obj1 = 0 ;
39047 char *kwnames[] = {
39048 (char *) "self",(char *) "_self", NULL
39049 };
39050
39051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39053 if (SWIG_arg_fail(1)) SWIG_fail;
39054 arg2 = obj1;
39055 {
39056 PyThreadState* __tstate = wxPyBeginAllowThreads();
39057 wxSizer__setOORInfo(arg1,arg2);
39058
39059 wxPyEndAllowThreads(__tstate);
39060 if (PyErr_Occurred()) SWIG_fail;
39061 }
39062 Py_INCREF(Py_None); resultobj = Py_None;
39063 return resultobj;
39064 fail:
39065 return NULL;
39066 }
39067
39068
39069 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39070 PyObject *resultobj;
39071 wxSizer *arg1 = (wxSizer *) 0 ;
39072 PyObject *arg2 = (PyObject *) 0 ;
39073 int arg3 = (int) 0 ;
39074 int arg4 = (int) 0 ;
39075 int arg5 = (int) 0 ;
39076 PyObject *arg6 = (PyObject *) NULL ;
39077 wxSizerItem *result;
39078 PyObject * obj0 = 0 ;
39079 PyObject * obj1 = 0 ;
39080 PyObject * obj2 = 0 ;
39081 PyObject * obj3 = 0 ;
39082 PyObject * obj4 = 0 ;
39083 PyObject * obj5 = 0 ;
39084 char *kwnames[] = {
39085 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39086 };
39087
39088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39090 if (SWIG_arg_fail(1)) SWIG_fail;
39091 arg2 = obj1;
39092 if (obj2) {
39093 {
39094 arg3 = (int)(SWIG_As_int(obj2));
39095 if (SWIG_arg_fail(3)) SWIG_fail;
39096 }
39097 }
39098 if (obj3) {
39099 {
39100 arg4 = (int)(SWIG_As_int(obj3));
39101 if (SWIG_arg_fail(4)) SWIG_fail;
39102 }
39103 }
39104 if (obj4) {
39105 {
39106 arg5 = (int)(SWIG_As_int(obj4));
39107 if (SWIG_arg_fail(5)) SWIG_fail;
39108 }
39109 }
39110 if (obj5) {
39111 arg6 = obj5;
39112 }
39113 {
39114 PyThreadState* __tstate = wxPyBeginAllowThreads();
39115 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39116
39117 wxPyEndAllowThreads(__tstate);
39118 if (PyErr_Occurred()) SWIG_fail;
39119 }
39120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39121 return resultobj;
39122 fail:
39123 return NULL;
39124 }
39125
39126
39127 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39128 PyObject *resultobj;
39129 wxSizer *arg1 = (wxSizer *) 0 ;
39130 int arg2 ;
39131 PyObject *arg3 = (PyObject *) 0 ;
39132 int arg4 = (int) 0 ;
39133 int arg5 = (int) 0 ;
39134 int arg6 = (int) 0 ;
39135 PyObject *arg7 = (PyObject *) NULL ;
39136 wxSizerItem *result;
39137 PyObject * obj0 = 0 ;
39138 PyObject * obj1 = 0 ;
39139 PyObject * obj2 = 0 ;
39140 PyObject * obj3 = 0 ;
39141 PyObject * obj4 = 0 ;
39142 PyObject * obj5 = 0 ;
39143 PyObject * obj6 = 0 ;
39144 char *kwnames[] = {
39145 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39146 };
39147
39148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39150 if (SWIG_arg_fail(1)) SWIG_fail;
39151 {
39152 arg2 = (int)(SWIG_As_int(obj1));
39153 if (SWIG_arg_fail(2)) SWIG_fail;
39154 }
39155 arg3 = obj2;
39156 if (obj3) {
39157 {
39158 arg4 = (int)(SWIG_As_int(obj3));
39159 if (SWIG_arg_fail(4)) SWIG_fail;
39160 }
39161 }
39162 if (obj4) {
39163 {
39164 arg5 = (int)(SWIG_As_int(obj4));
39165 if (SWIG_arg_fail(5)) SWIG_fail;
39166 }
39167 }
39168 if (obj5) {
39169 {
39170 arg6 = (int)(SWIG_As_int(obj5));
39171 if (SWIG_arg_fail(6)) SWIG_fail;
39172 }
39173 }
39174 if (obj6) {
39175 arg7 = obj6;
39176 }
39177 {
39178 PyThreadState* __tstate = wxPyBeginAllowThreads();
39179 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39180
39181 wxPyEndAllowThreads(__tstate);
39182 if (PyErr_Occurred()) SWIG_fail;
39183 }
39184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39185 return resultobj;
39186 fail:
39187 return NULL;
39188 }
39189
39190
39191 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39192 PyObject *resultobj;
39193 wxSizer *arg1 = (wxSizer *) 0 ;
39194 PyObject *arg2 = (PyObject *) 0 ;
39195 int arg3 = (int) 0 ;
39196 int arg4 = (int) 0 ;
39197 int arg5 = (int) 0 ;
39198 PyObject *arg6 = (PyObject *) NULL ;
39199 wxSizerItem *result;
39200 PyObject * obj0 = 0 ;
39201 PyObject * obj1 = 0 ;
39202 PyObject * obj2 = 0 ;
39203 PyObject * obj3 = 0 ;
39204 PyObject * obj4 = 0 ;
39205 PyObject * obj5 = 0 ;
39206 char *kwnames[] = {
39207 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39208 };
39209
39210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39212 if (SWIG_arg_fail(1)) SWIG_fail;
39213 arg2 = obj1;
39214 if (obj2) {
39215 {
39216 arg3 = (int)(SWIG_As_int(obj2));
39217 if (SWIG_arg_fail(3)) SWIG_fail;
39218 }
39219 }
39220 if (obj3) {
39221 {
39222 arg4 = (int)(SWIG_As_int(obj3));
39223 if (SWIG_arg_fail(4)) SWIG_fail;
39224 }
39225 }
39226 if (obj4) {
39227 {
39228 arg5 = (int)(SWIG_As_int(obj4));
39229 if (SWIG_arg_fail(5)) SWIG_fail;
39230 }
39231 }
39232 if (obj5) {
39233 arg6 = obj5;
39234 }
39235 {
39236 PyThreadState* __tstate = wxPyBeginAllowThreads();
39237 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39238
39239 wxPyEndAllowThreads(__tstate);
39240 if (PyErr_Occurred()) SWIG_fail;
39241 }
39242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39243 return resultobj;
39244 fail:
39245 return NULL;
39246 }
39247
39248
39249 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39250 PyObject *resultobj;
39251 wxSizer *arg1 = (wxSizer *) 0 ;
39252 PyObject *arg2 = (PyObject *) 0 ;
39253 bool result;
39254 PyObject * obj0 = 0 ;
39255 PyObject * obj1 = 0 ;
39256 char *kwnames[] = {
39257 (char *) "self",(char *) "item", NULL
39258 };
39259
39260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39262 if (SWIG_arg_fail(1)) SWIG_fail;
39263 arg2 = obj1;
39264 {
39265 PyThreadState* __tstate = wxPyBeginAllowThreads();
39266 result = (bool)wxSizer_Remove(arg1,arg2);
39267
39268 wxPyEndAllowThreads(__tstate);
39269 if (PyErr_Occurred()) SWIG_fail;
39270 }
39271 {
39272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39273 }
39274 return resultobj;
39275 fail:
39276 return NULL;
39277 }
39278
39279
39280 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39281 PyObject *resultobj;
39282 wxSizer *arg1 = (wxSizer *) 0 ;
39283 PyObject *arg2 = (PyObject *) 0 ;
39284 bool result;
39285 PyObject * obj0 = 0 ;
39286 PyObject * obj1 = 0 ;
39287 char *kwnames[] = {
39288 (char *) "self",(char *) "item", NULL
39289 };
39290
39291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39293 if (SWIG_arg_fail(1)) SWIG_fail;
39294 arg2 = obj1;
39295 {
39296 PyThreadState* __tstate = wxPyBeginAllowThreads();
39297 result = (bool)wxSizer_Detach(arg1,arg2);
39298
39299 wxPyEndAllowThreads(__tstate);
39300 if (PyErr_Occurred()) SWIG_fail;
39301 }
39302 {
39303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39304 }
39305 return resultobj;
39306 fail:
39307 return NULL;
39308 }
39309
39310
39311 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39312 PyObject *resultobj;
39313 wxSizer *arg1 = (wxSizer *) 0 ;
39314 PyObject *arg2 = (PyObject *) 0 ;
39315 wxSizerItem *result;
39316 PyObject * obj0 = 0 ;
39317 PyObject * obj1 = 0 ;
39318 char *kwnames[] = {
39319 (char *) "self",(char *) "item", NULL
39320 };
39321
39322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39324 if (SWIG_arg_fail(1)) SWIG_fail;
39325 arg2 = obj1;
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39329
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj;
39342 wxSizer *arg1 = (wxSizer *) 0 ;
39343 PyObject *arg2 = (PyObject *) 0 ;
39344 wxSize *arg3 = 0 ;
39345 wxSize temp3 ;
39346 PyObject * obj0 = 0 ;
39347 PyObject * obj1 = 0 ;
39348 PyObject * obj2 = 0 ;
39349 char *kwnames[] = {
39350 (char *) "self",(char *) "item",(char *) "size", NULL
39351 };
39352
39353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39355 if (SWIG_arg_fail(1)) SWIG_fail;
39356 arg2 = obj1;
39357 {
39358 arg3 = &temp3;
39359 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39360 }
39361 {
39362 PyThreadState* __tstate = wxPyBeginAllowThreads();
39363 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39364
39365 wxPyEndAllowThreads(__tstate);
39366 if (PyErr_Occurred()) SWIG_fail;
39367 }
39368 Py_INCREF(Py_None); resultobj = Py_None;
39369 return resultobj;
39370 fail:
39371 return NULL;
39372 }
39373
39374
39375 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39376 PyObject *resultobj;
39377 wxSizer *arg1 = (wxSizer *) 0 ;
39378 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39379 wxSizerItem *result;
39380 PyObject * obj0 = 0 ;
39381 PyObject * obj1 = 0 ;
39382 char *kwnames[] = {
39383 (char *) "self",(char *) "item", NULL
39384 };
39385
39386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39388 if (SWIG_arg_fail(1)) SWIG_fail;
39389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(2)) SWIG_fail;
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 result = (wxSizerItem *)(arg1)->Add(arg2);
39394
39395 wxPyEndAllowThreads(__tstate);
39396 if (PyErr_Occurred()) SWIG_fail;
39397 }
39398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39399 return resultobj;
39400 fail:
39401 return NULL;
39402 }
39403
39404
39405 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39406 PyObject *resultobj;
39407 wxSizer *arg1 = (wxSizer *) 0 ;
39408 size_t arg2 ;
39409 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39410 wxSizerItem *result;
39411 PyObject * obj0 = 0 ;
39412 PyObject * obj1 = 0 ;
39413 PyObject * obj2 = 0 ;
39414 char *kwnames[] = {
39415 (char *) "self",(char *) "index",(char *) "item", NULL
39416 };
39417
39418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39420 if (SWIG_arg_fail(1)) SWIG_fail;
39421 {
39422 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39423 if (SWIG_arg_fail(2)) SWIG_fail;
39424 }
39425 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39426 if (SWIG_arg_fail(3)) SWIG_fail;
39427 {
39428 PyThreadState* __tstate = wxPyBeginAllowThreads();
39429 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39430
39431 wxPyEndAllowThreads(__tstate);
39432 if (PyErr_Occurred()) SWIG_fail;
39433 }
39434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39435 return resultobj;
39436 fail:
39437 return NULL;
39438 }
39439
39440
39441 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39442 PyObject *resultobj;
39443 wxSizer *arg1 = (wxSizer *) 0 ;
39444 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39445 wxSizerItem *result;
39446 PyObject * obj0 = 0 ;
39447 PyObject * obj1 = 0 ;
39448 char *kwnames[] = {
39449 (char *) "self",(char *) "item", NULL
39450 };
39451
39452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39454 if (SWIG_arg_fail(1)) SWIG_fail;
39455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39456 if (SWIG_arg_fail(2)) SWIG_fail;
39457 {
39458 PyThreadState* __tstate = wxPyBeginAllowThreads();
39459 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39460
39461 wxPyEndAllowThreads(__tstate);
39462 if (PyErr_Occurred()) SWIG_fail;
39463 }
39464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj;
39473 wxSizer *arg1 = (wxSizer *) 0 ;
39474 int arg2 ;
39475 int arg3 ;
39476 int arg4 ;
39477 int arg5 ;
39478 PyObject * obj0 = 0 ;
39479 PyObject * obj1 = 0 ;
39480 PyObject * obj2 = 0 ;
39481 PyObject * obj3 = 0 ;
39482 PyObject * obj4 = 0 ;
39483 char *kwnames[] = {
39484 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39485 };
39486
39487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39489 if (SWIG_arg_fail(1)) SWIG_fail;
39490 {
39491 arg2 = (int)(SWIG_As_int(obj1));
39492 if (SWIG_arg_fail(2)) SWIG_fail;
39493 }
39494 {
39495 arg3 = (int)(SWIG_As_int(obj2));
39496 if (SWIG_arg_fail(3)) SWIG_fail;
39497 }
39498 {
39499 arg4 = (int)(SWIG_As_int(obj3));
39500 if (SWIG_arg_fail(4)) SWIG_fail;
39501 }
39502 {
39503 arg5 = (int)(SWIG_As_int(obj4));
39504 if (SWIG_arg_fail(5)) SWIG_fail;
39505 }
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39509
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 Py_INCREF(Py_None); resultobj = Py_None;
39514 return resultobj;
39515 fail:
39516 return NULL;
39517 }
39518
39519
39520 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39521 PyObject *resultobj;
39522 wxSizer *arg1 = (wxSizer *) 0 ;
39523 wxSize *arg2 = 0 ;
39524 wxSize temp2 ;
39525 PyObject * obj0 = 0 ;
39526 PyObject * obj1 = 0 ;
39527 char *kwnames[] = {
39528 (char *) "self",(char *) "size", NULL
39529 };
39530
39531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39533 if (SWIG_arg_fail(1)) SWIG_fail;
39534 {
39535 arg2 = &temp2;
39536 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39537 }
39538 {
39539 PyThreadState* __tstate = wxPyBeginAllowThreads();
39540 (arg1)->SetMinSize((wxSize const &)*arg2);
39541
39542 wxPyEndAllowThreads(__tstate);
39543 if (PyErr_Occurred()) SWIG_fail;
39544 }
39545 Py_INCREF(Py_None); resultobj = Py_None;
39546 return resultobj;
39547 fail:
39548 return NULL;
39549 }
39550
39551
39552 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39553 PyObject *resultobj;
39554 wxSizer *arg1 = (wxSizer *) 0 ;
39555 wxSize result;
39556 PyObject * obj0 = 0 ;
39557 char *kwnames[] = {
39558 (char *) "self", NULL
39559 };
39560
39561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39563 if (SWIG_arg_fail(1)) SWIG_fail;
39564 {
39565 PyThreadState* __tstate = wxPyBeginAllowThreads();
39566 result = (arg1)->GetSize();
39567
39568 wxPyEndAllowThreads(__tstate);
39569 if (PyErr_Occurred()) SWIG_fail;
39570 }
39571 {
39572 wxSize * resultptr;
39573 resultptr = new wxSize((wxSize &)(result));
39574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39575 }
39576 return resultobj;
39577 fail:
39578 return NULL;
39579 }
39580
39581
39582 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39583 PyObject *resultobj;
39584 wxSizer *arg1 = (wxSizer *) 0 ;
39585 wxPoint result;
39586 PyObject * obj0 = 0 ;
39587 char *kwnames[] = {
39588 (char *) "self", NULL
39589 };
39590
39591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39593 if (SWIG_arg_fail(1)) SWIG_fail;
39594 {
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 result = (arg1)->GetPosition();
39597
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 {
39602 wxPoint * resultptr;
39603 resultptr = new wxPoint((wxPoint &)(result));
39604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39605 }
39606 return resultobj;
39607 fail:
39608 return NULL;
39609 }
39610
39611
39612 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39613 PyObject *resultobj;
39614 wxSizer *arg1 = (wxSizer *) 0 ;
39615 wxSize result;
39616 PyObject * obj0 = 0 ;
39617 char *kwnames[] = {
39618 (char *) "self", NULL
39619 };
39620
39621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39623 if (SWIG_arg_fail(1)) SWIG_fail;
39624 {
39625 PyThreadState* __tstate = wxPyBeginAllowThreads();
39626 result = (arg1)->GetMinSize();
39627
39628 wxPyEndAllowThreads(__tstate);
39629 if (PyErr_Occurred()) SWIG_fail;
39630 }
39631 {
39632 wxSize * resultptr;
39633 resultptr = new wxSize((wxSize &)(result));
39634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39635 }
39636 return resultobj;
39637 fail:
39638 return NULL;
39639 }
39640
39641
39642 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39643 PyObject *resultobj;
39644 wxSizer *arg1 = (wxSizer *) 0 ;
39645 PyObject * obj0 = 0 ;
39646 char *kwnames[] = {
39647 (char *) "self", NULL
39648 };
39649
39650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39652 if (SWIG_arg_fail(1)) SWIG_fail;
39653 {
39654 PyThreadState* __tstate = wxPyBeginAllowThreads();
39655 (arg1)->RecalcSizes();
39656
39657 wxPyEndAllowThreads(__tstate);
39658 if (PyErr_Occurred()) SWIG_fail;
39659 }
39660 Py_INCREF(Py_None); resultobj = Py_None;
39661 return resultobj;
39662 fail:
39663 return NULL;
39664 }
39665
39666
39667 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39668 PyObject *resultobj;
39669 wxSizer *arg1 = (wxSizer *) 0 ;
39670 wxSize result;
39671 PyObject * obj0 = 0 ;
39672 char *kwnames[] = {
39673 (char *) "self", NULL
39674 };
39675
39676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39678 if (SWIG_arg_fail(1)) SWIG_fail;
39679 {
39680 PyThreadState* __tstate = wxPyBeginAllowThreads();
39681 result = (arg1)->CalcMin();
39682
39683 wxPyEndAllowThreads(__tstate);
39684 if (PyErr_Occurred()) SWIG_fail;
39685 }
39686 {
39687 wxSize * resultptr;
39688 resultptr = new wxSize((wxSize &)(result));
39689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39690 }
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj;
39699 wxSizer *arg1 = (wxSizer *) 0 ;
39700 PyObject * obj0 = 0 ;
39701 char *kwnames[] = {
39702 (char *) "self", NULL
39703 };
39704
39705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39707 if (SWIG_arg_fail(1)) SWIG_fail;
39708 {
39709 PyThreadState* __tstate = wxPyBeginAllowThreads();
39710 (arg1)->Layout();
39711
39712 wxPyEndAllowThreads(__tstate);
39713 if (PyErr_Occurred()) SWIG_fail;
39714 }
39715 Py_INCREF(Py_None); resultobj = Py_None;
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj;
39724 wxSizer *arg1 = (wxSizer *) 0 ;
39725 wxWindow *arg2 = (wxWindow *) 0 ;
39726 wxSize result;
39727 PyObject * obj0 = 0 ;
39728 PyObject * obj1 = 0 ;
39729 char *kwnames[] = {
39730 (char *) "self",(char *) "window", NULL
39731 };
39732
39733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39735 if (SWIG_arg_fail(1)) SWIG_fail;
39736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39737 if (SWIG_arg_fail(2)) SWIG_fail;
39738 {
39739 PyThreadState* __tstate = wxPyBeginAllowThreads();
39740 result = (arg1)->Fit(arg2);
39741
39742 wxPyEndAllowThreads(__tstate);
39743 if (PyErr_Occurred()) SWIG_fail;
39744 }
39745 {
39746 wxSize * resultptr;
39747 resultptr = new wxSize((wxSize &)(result));
39748 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39749 }
39750 return resultobj;
39751 fail:
39752 return NULL;
39753 }
39754
39755
39756 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39757 PyObject *resultobj;
39758 wxSizer *arg1 = (wxSizer *) 0 ;
39759 wxWindow *arg2 = (wxWindow *) 0 ;
39760 PyObject * obj0 = 0 ;
39761 PyObject * obj1 = 0 ;
39762 char *kwnames[] = {
39763 (char *) "self",(char *) "window", NULL
39764 };
39765
39766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39768 if (SWIG_arg_fail(1)) SWIG_fail;
39769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39770 if (SWIG_arg_fail(2)) SWIG_fail;
39771 {
39772 PyThreadState* __tstate = wxPyBeginAllowThreads();
39773 (arg1)->FitInside(arg2);
39774
39775 wxPyEndAllowThreads(__tstate);
39776 if (PyErr_Occurred()) SWIG_fail;
39777 }
39778 Py_INCREF(Py_None); resultobj = Py_None;
39779 return resultobj;
39780 fail:
39781 return NULL;
39782 }
39783
39784
39785 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39786 PyObject *resultobj;
39787 wxSizer *arg1 = (wxSizer *) 0 ;
39788 wxWindow *arg2 = (wxWindow *) 0 ;
39789 PyObject * obj0 = 0 ;
39790 PyObject * obj1 = 0 ;
39791 char *kwnames[] = {
39792 (char *) "self",(char *) "window", NULL
39793 };
39794
39795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39797 if (SWIG_arg_fail(1)) SWIG_fail;
39798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39799 if (SWIG_arg_fail(2)) SWIG_fail;
39800 {
39801 PyThreadState* __tstate = wxPyBeginAllowThreads();
39802 (arg1)->SetSizeHints(arg2);
39803
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 Py_INCREF(Py_None); resultobj = Py_None;
39808 return resultobj;
39809 fail:
39810 return NULL;
39811 }
39812
39813
39814 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39815 PyObject *resultobj;
39816 wxSizer *arg1 = (wxSizer *) 0 ;
39817 wxWindow *arg2 = (wxWindow *) 0 ;
39818 PyObject * obj0 = 0 ;
39819 PyObject * obj1 = 0 ;
39820 char *kwnames[] = {
39821 (char *) "self",(char *) "window", NULL
39822 };
39823
39824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39826 if (SWIG_arg_fail(1)) SWIG_fail;
39827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39828 if (SWIG_arg_fail(2)) SWIG_fail;
39829 {
39830 PyThreadState* __tstate = wxPyBeginAllowThreads();
39831 (arg1)->SetVirtualSizeHints(arg2);
39832
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 Py_INCREF(Py_None); resultobj = Py_None;
39837 return resultobj;
39838 fail:
39839 return NULL;
39840 }
39841
39842
39843 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39844 PyObject *resultobj;
39845 wxSizer *arg1 = (wxSizer *) 0 ;
39846 bool arg2 = (bool) false ;
39847 PyObject * obj0 = 0 ;
39848 PyObject * obj1 = 0 ;
39849 char *kwnames[] = {
39850 (char *) "self",(char *) "deleteWindows", NULL
39851 };
39852
39853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39855 if (SWIG_arg_fail(1)) SWIG_fail;
39856 if (obj1) {
39857 {
39858 arg2 = (bool)(SWIG_As_bool(obj1));
39859 if (SWIG_arg_fail(2)) SWIG_fail;
39860 }
39861 }
39862 {
39863 PyThreadState* __tstate = wxPyBeginAllowThreads();
39864 (arg1)->Clear(arg2);
39865
39866 wxPyEndAllowThreads(__tstate);
39867 if (PyErr_Occurred()) SWIG_fail;
39868 }
39869 Py_INCREF(Py_None); resultobj = Py_None;
39870 return resultobj;
39871 fail:
39872 return NULL;
39873 }
39874
39875
39876 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39877 PyObject *resultobj;
39878 wxSizer *arg1 = (wxSizer *) 0 ;
39879 PyObject * obj0 = 0 ;
39880 char *kwnames[] = {
39881 (char *) "self", NULL
39882 };
39883
39884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39886 if (SWIG_arg_fail(1)) SWIG_fail;
39887 {
39888 PyThreadState* __tstate = wxPyBeginAllowThreads();
39889 (arg1)->DeleteWindows();
39890
39891 wxPyEndAllowThreads(__tstate);
39892 if (PyErr_Occurred()) SWIG_fail;
39893 }
39894 Py_INCREF(Py_None); resultobj = Py_None;
39895 return resultobj;
39896 fail:
39897 return NULL;
39898 }
39899
39900
39901 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39902 PyObject *resultobj;
39903 wxSizer *arg1 = (wxSizer *) 0 ;
39904 PyObject *result;
39905 PyObject * obj0 = 0 ;
39906 char *kwnames[] = {
39907 (char *) "self", NULL
39908 };
39909
39910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39912 if (SWIG_arg_fail(1)) SWIG_fail;
39913 {
39914 PyThreadState* __tstate = wxPyBeginAllowThreads();
39915 result = (PyObject *)wxSizer_GetChildren(arg1);
39916
39917 wxPyEndAllowThreads(__tstate);
39918 if (PyErr_Occurred()) SWIG_fail;
39919 }
39920 resultobj = result;
39921 return resultobj;
39922 fail:
39923 return NULL;
39924 }
39925
39926
39927 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39928 PyObject *resultobj;
39929 wxSizer *arg1 = (wxSizer *) 0 ;
39930 PyObject *arg2 = (PyObject *) 0 ;
39931 bool arg3 = (bool) true ;
39932 bool arg4 = (bool) false ;
39933 bool result;
39934 PyObject * obj0 = 0 ;
39935 PyObject * obj1 = 0 ;
39936 PyObject * obj2 = 0 ;
39937 PyObject * obj3 = 0 ;
39938 char *kwnames[] = {
39939 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39940 };
39941
39942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39944 if (SWIG_arg_fail(1)) SWIG_fail;
39945 arg2 = obj1;
39946 if (obj2) {
39947 {
39948 arg3 = (bool)(SWIG_As_bool(obj2));
39949 if (SWIG_arg_fail(3)) SWIG_fail;
39950 }
39951 }
39952 if (obj3) {
39953 {
39954 arg4 = (bool)(SWIG_As_bool(obj3));
39955 if (SWIG_arg_fail(4)) SWIG_fail;
39956 }
39957 }
39958 {
39959 PyThreadState* __tstate = wxPyBeginAllowThreads();
39960 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39961
39962 wxPyEndAllowThreads(__tstate);
39963 if (PyErr_Occurred()) SWIG_fail;
39964 }
39965 {
39966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39967 }
39968 return resultobj;
39969 fail:
39970 return NULL;
39971 }
39972
39973
39974 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39975 PyObject *resultobj;
39976 wxSizer *arg1 = (wxSizer *) 0 ;
39977 PyObject *arg2 = (PyObject *) 0 ;
39978 bool result;
39979 PyObject * obj0 = 0 ;
39980 PyObject * obj1 = 0 ;
39981 char *kwnames[] = {
39982 (char *) "self",(char *) "item", NULL
39983 };
39984
39985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39987 if (SWIG_arg_fail(1)) SWIG_fail;
39988 arg2 = obj1;
39989 {
39990 PyThreadState* __tstate = wxPyBeginAllowThreads();
39991 result = (bool)wxSizer_IsShown(arg1,arg2);
39992
39993 wxPyEndAllowThreads(__tstate);
39994 if (PyErr_Occurred()) SWIG_fail;
39995 }
39996 {
39997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39998 }
39999 return resultobj;
40000 fail:
40001 return NULL;
40002 }
40003
40004
40005 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40006 PyObject *resultobj;
40007 wxSizer *arg1 = (wxSizer *) 0 ;
40008 bool arg2 ;
40009 PyObject * obj0 = 0 ;
40010 PyObject * obj1 = 0 ;
40011 char *kwnames[] = {
40012 (char *) "self",(char *) "show", NULL
40013 };
40014
40015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40017 if (SWIG_arg_fail(1)) SWIG_fail;
40018 {
40019 arg2 = (bool)(SWIG_As_bool(obj1));
40020 if (SWIG_arg_fail(2)) SWIG_fail;
40021 }
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 (arg1)->ShowItems(arg2);
40025
40026 wxPyEndAllowThreads(__tstate);
40027 if (PyErr_Occurred()) SWIG_fail;
40028 }
40029 Py_INCREF(Py_None); resultobj = Py_None;
40030 return resultobj;
40031 fail:
40032 return NULL;
40033 }
40034
40035
40036 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40037 PyObject *obj;
40038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40039 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40040 Py_INCREF(obj);
40041 return Py_BuildValue((char *)"");
40042 }
40043 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj;
40045 wxPySizer *result;
40046 char *kwnames[] = {
40047 NULL
40048 };
40049
40050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40051 {
40052 PyThreadState* __tstate = wxPyBeginAllowThreads();
40053 result = (wxPySizer *)new wxPySizer();
40054
40055 wxPyEndAllowThreads(__tstate);
40056 if (PyErr_Occurred()) SWIG_fail;
40057 }
40058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40066 PyObject *resultobj;
40067 wxPySizer *arg1 = (wxPySizer *) 0 ;
40068 PyObject *arg2 = (PyObject *) 0 ;
40069 PyObject *arg3 = (PyObject *) 0 ;
40070 PyObject * obj0 = 0 ;
40071 PyObject * obj1 = 0 ;
40072 PyObject * obj2 = 0 ;
40073 char *kwnames[] = {
40074 (char *) "self",(char *) "self",(char *) "_class", NULL
40075 };
40076
40077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40079 if (SWIG_arg_fail(1)) SWIG_fail;
40080 arg2 = obj1;
40081 arg3 = obj2;
40082 {
40083 PyThreadState* __tstate = wxPyBeginAllowThreads();
40084 (arg1)->_setCallbackInfo(arg2,arg3);
40085
40086 wxPyEndAllowThreads(__tstate);
40087 if (PyErr_Occurred()) SWIG_fail;
40088 }
40089 Py_INCREF(Py_None); resultobj = Py_None;
40090 return resultobj;
40091 fail:
40092 return NULL;
40093 }
40094
40095
40096 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40097 PyObject *obj;
40098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40099 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40100 Py_INCREF(obj);
40101 return Py_BuildValue((char *)"");
40102 }
40103 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40104 PyObject *resultobj;
40105 int arg1 = (int) wxHORIZONTAL ;
40106 wxBoxSizer *result;
40107 PyObject * obj0 = 0 ;
40108 char *kwnames[] = {
40109 (char *) "orient", NULL
40110 };
40111
40112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40113 if (obj0) {
40114 {
40115 arg1 = (int)(SWIG_As_int(obj0));
40116 if (SWIG_arg_fail(1)) SWIG_fail;
40117 }
40118 }
40119 {
40120 PyThreadState* __tstate = wxPyBeginAllowThreads();
40121 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40122
40123 wxPyEndAllowThreads(__tstate);
40124 if (PyErr_Occurred()) SWIG_fail;
40125 }
40126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40127 return resultobj;
40128 fail:
40129 return NULL;
40130 }
40131
40132
40133 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40134 PyObject *resultobj;
40135 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40136 int result;
40137 PyObject * obj0 = 0 ;
40138 char *kwnames[] = {
40139 (char *) "self", NULL
40140 };
40141
40142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40144 if (SWIG_arg_fail(1)) SWIG_fail;
40145 {
40146 PyThreadState* __tstate = wxPyBeginAllowThreads();
40147 result = (int)(arg1)->GetOrientation();
40148
40149 wxPyEndAllowThreads(__tstate);
40150 if (PyErr_Occurred()) SWIG_fail;
40151 }
40152 {
40153 resultobj = SWIG_From_int((int)(result));
40154 }
40155 return resultobj;
40156 fail:
40157 return NULL;
40158 }
40159
40160
40161 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40162 PyObject *resultobj;
40163 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40164 int arg2 ;
40165 PyObject * obj0 = 0 ;
40166 PyObject * obj1 = 0 ;
40167 char *kwnames[] = {
40168 (char *) "self",(char *) "orient", NULL
40169 };
40170
40171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40173 if (SWIG_arg_fail(1)) SWIG_fail;
40174 {
40175 arg2 = (int)(SWIG_As_int(obj1));
40176 if (SWIG_arg_fail(2)) SWIG_fail;
40177 }
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 (arg1)->SetOrientation(arg2);
40181
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 Py_INCREF(Py_None); resultobj = Py_None;
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40193 PyObject *obj;
40194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40195 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40196 Py_INCREF(obj);
40197 return Py_BuildValue((char *)"");
40198 }
40199 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40200 PyObject *resultobj;
40201 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40202 int arg2 = (int) wxHORIZONTAL ;
40203 wxStaticBoxSizer *result;
40204 PyObject * obj0 = 0 ;
40205 PyObject * obj1 = 0 ;
40206 char *kwnames[] = {
40207 (char *) "box",(char *) "orient", NULL
40208 };
40209
40210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40212 if (SWIG_arg_fail(1)) SWIG_fail;
40213 if (obj1) {
40214 {
40215 arg2 = (int)(SWIG_As_int(obj1));
40216 if (SWIG_arg_fail(2)) SWIG_fail;
40217 }
40218 }
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40222
40223 wxPyEndAllowThreads(__tstate);
40224 if (PyErr_Occurred()) SWIG_fail;
40225 }
40226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40227 return resultobj;
40228 fail:
40229 return NULL;
40230 }
40231
40232
40233 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40234 PyObject *resultobj;
40235 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40236 wxStaticBox *result;
40237 PyObject * obj0 = 0 ;
40238 char *kwnames[] = {
40239 (char *) "self", NULL
40240 };
40241
40242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40244 if (SWIG_arg_fail(1)) SWIG_fail;
40245 {
40246 PyThreadState* __tstate = wxPyBeginAllowThreads();
40247 result = (wxStaticBox *)(arg1)->GetStaticBox();
40248
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 {
40253 resultobj = wxPyMake_wxObject(result, 0);
40254 }
40255 return resultobj;
40256 fail:
40257 return NULL;
40258 }
40259
40260
40261 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40262 PyObject *obj;
40263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40264 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40265 Py_INCREF(obj);
40266 return Py_BuildValue((char *)"");
40267 }
40268 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40269 PyObject *resultobj;
40270 int arg1 = (int) 1 ;
40271 int arg2 = (int) 0 ;
40272 int arg3 = (int) 0 ;
40273 int arg4 = (int) 0 ;
40274 wxGridSizer *result;
40275 PyObject * obj0 = 0 ;
40276 PyObject * obj1 = 0 ;
40277 PyObject * obj2 = 0 ;
40278 PyObject * obj3 = 0 ;
40279 char *kwnames[] = {
40280 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40281 };
40282
40283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40284 if (obj0) {
40285 {
40286 arg1 = (int)(SWIG_As_int(obj0));
40287 if (SWIG_arg_fail(1)) SWIG_fail;
40288 }
40289 }
40290 if (obj1) {
40291 {
40292 arg2 = (int)(SWIG_As_int(obj1));
40293 if (SWIG_arg_fail(2)) SWIG_fail;
40294 }
40295 }
40296 if (obj2) {
40297 {
40298 arg3 = (int)(SWIG_As_int(obj2));
40299 if (SWIG_arg_fail(3)) SWIG_fail;
40300 }
40301 }
40302 if (obj3) {
40303 {
40304 arg4 = (int)(SWIG_As_int(obj3));
40305 if (SWIG_arg_fail(4)) SWIG_fail;
40306 }
40307 }
40308 {
40309 PyThreadState* __tstate = wxPyBeginAllowThreads();
40310 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40311
40312 wxPyEndAllowThreads(__tstate);
40313 if (PyErr_Occurred()) SWIG_fail;
40314 }
40315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40316 return resultobj;
40317 fail:
40318 return NULL;
40319 }
40320
40321
40322 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40323 PyObject *resultobj;
40324 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40325 int arg2 ;
40326 PyObject * obj0 = 0 ;
40327 PyObject * obj1 = 0 ;
40328 char *kwnames[] = {
40329 (char *) "self",(char *) "cols", NULL
40330 };
40331
40332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40334 if (SWIG_arg_fail(1)) SWIG_fail;
40335 {
40336 arg2 = (int)(SWIG_As_int(obj1));
40337 if (SWIG_arg_fail(2)) SWIG_fail;
40338 }
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 (arg1)->SetCols(arg2);
40342
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 Py_INCREF(Py_None); resultobj = Py_None;
40347 return resultobj;
40348 fail:
40349 return NULL;
40350 }
40351
40352
40353 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40354 PyObject *resultobj;
40355 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40356 int arg2 ;
40357 PyObject * obj0 = 0 ;
40358 PyObject * obj1 = 0 ;
40359 char *kwnames[] = {
40360 (char *) "self",(char *) "rows", NULL
40361 };
40362
40363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40365 if (SWIG_arg_fail(1)) SWIG_fail;
40366 {
40367 arg2 = (int)(SWIG_As_int(obj1));
40368 if (SWIG_arg_fail(2)) SWIG_fail;
40369 }
40370 {
40371 PyThreadState* __tstate = wxPyBeginAllowThreads();
40372 (arg1)->SetRows(arg2);
40373
40374 wxPyEndAllowThreads(__tstate);
40375 if (PyErr_Occurred()) SWIG_fail;
40376 }
40377 Py_INCREF(Py_None); resultobj = Py_None;
40378 return resultobj;
40379 fail:
40380 return NULL;
40381 }
40382
40383
40384 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40385 PyObject *resultobj;
40386 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40387 int arg2 ;
40388 PyObject * obj0 = 0 ;
40389 PyObject * obj1 = 0 ;
40390 char *kwnames[] = {
40391 (char *) "self",(char *) "gap", NULL
40392 };
40393
40394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40396 if (SWIG_arg_fail(1)) SWIG_fail;
40397 {
40398 arg2 = (int)(SWIG_As_int(obj1));
40399 if (SWIG_arg_fail(2)) SWIG_fail;
40400 }
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 (arg1)->SetVGap(arg2);
40404
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 Py_INCREF(Py_None); resultobj = Py_None;
40409 return resultobj;
40410 fail:
40411 return NULL;
40412 }
40413
40414
40415 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40416 PyObject *resultobj;
40417 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40418 int arg2 ;
40419 PyObject * obj0 = 0 ;
40420 PyObject * obj1 = 0 ;
40421 char *kwnames[] = {
40422 (char *) "self",(char *) "gap", NULL
40423 };
40424
40425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40427 if (SWIG_arg_fail(1)) SWIG_fail;
40428 {
40429 arg2 = (int)(SWIG_As_int(obj1));
40430 if (SWIG_arg_fail(2)) SWIG_fail;
40431 }
40432 {
40433 PyThreadState* __tstate = wxPyBeginAllowThreads();
40434 (arg1)->SetHGap(arg2);
40435
40436 wxPyEndAllowThreads(__tstate);
40437 if (PyErr_Occurred()) SWIG_fail;
40438 }
40439 Py_INCREF(Py_None); resultobj = Py_None;
40440 return resultobj;
40441 fail:
40442 return NULL;
40443 }
40444
40445
40446 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40447 PyObject *resultobj;
40448 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40449 int result;
40450 PyObject * obj0 = 0 ;
40451 char *kwnames[] = {
40452 (char *) "self", NULL
40453 };
40454
40455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40457 if (SWIG_arg_fail(1)) SWIG_fail;
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 result = (int)(arg1)->GetCols();
40461
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 {
40466 resultobj = SWIG_From_int((int)(result));
40467 }
40468 return resultobj;
40469 fail:
40470 return NULL;
40471 }
40472
40473
40474 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40475 PyObject *resultobj;
40476 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40477 int result;
40478 PyObject * obj0 = 0 ;
40479 char *kwnames[] = {
40480 (char *) "self", NULL
40481 };
40482
40483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40485 if (SWIG_arg_fail(1)) SWIG_fail;
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = (int)(arg1)->GetRows();
40489
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 {
40494 resultobj = SWIG_From_int((int)(result));
40495 }
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40503 PyObject *resultobj;
40504 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40505 int result;
40506 PyObject * obj0 = 0 ;
40507 char *kwnames[] = {
40508 (char *) "self", NULL
40509 };
40510
40511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40513 if (SWIG_arg_fail(1)) SWIG_fail;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = (int)(arg1)->GetVGap();
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 resultobj = SWIG_From_int((int)(result));
40523 }
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj;
40532 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40533 int result;
40534 PyObject * obj0 = 0 ;
40535 char *kwnames[] = {
40536 (char *) "self", NULL
40537 };
40538
40539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40541 if (SWIG_arg_fail(1)) SWIG_fail;
40542 {
40543 PyThreadState* __tstate = wxPyBeginAllowThreads();
40544 result = (int)(arg1)->GetHGap();
40545
40546 wxPyEndAllowThreads(__tstate);
40547 if (PyErr_Occurred()) SWIG_fail;
40548 }
40549 {
40550 resultobj = SWIG_From_int((int)(result));
40551 }
40552 return resultobj;
40553 fail:
40554 return NULL;
40555 }
40556
40557
40558 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40559 PyObject *obj;
40560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40561 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40562 Py_INCREF(obj);
40563 return Py_BuildValue((char *)"");
40564 }
40565 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj;
40567 int arg1 = (int) 1 ;
40568 int arg2 = (int) 0 ;
40569 int arg3 = (int) 0 ;
40570 int arg4 = (int) 0 ;
40571 wxFlexGridSizer *result;
40572 PyObject * obj0 = 0 ;
40573 PyObject * obj1 = 0 ;
40574 PyObject * obj2 = 0 ;
40575 PyObject * obj3 = 0 ;
40576 char *kwnames[] = {
40577 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40578 };
40579
40580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40581 if (obj0) {
40582 {
40583 arg1 = (int)(SWIG_As_int(obj0));
40584 if (SWIG_arg_fail(1)) SWIG_fail;
40585 }
40586 }
40587 if (obj1) {
40588 {
40589 arg2 = (int)(SWIG_As_int(obj1));
40590 if (SWIG_arg_fail(2)) SWIG_fail;
40591 }
40592 }
40593 if (obj2) {
40594 {
40595 arg3 = (int)(SWIG_As_int(obj2));
40596 if (SWIG_arg_fail(3)) SWIG_fail;
40597 }
40598 }
40599 if (obj3) {
40600 {
40601 arg4 = (int)(SWIG_As_int(obj3));
40602 if (SWIG_arg_fail(4)) SWIG_fail;
40603 }
40604 }
40605 {
40606 PyThreadState* __tstate = wxPyBeginAllowThreads();
40607 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40608
40609 wxPyEndAllowThreads(__tstate);
40610 if (PyErr_Occurred()) SWIG_fail;
40611 }
40612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40613 return resultobj;
40614 fail:
40615 return NULL;
40616 }
40617
40618
40619 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40620 PyObject *resultobj;
40621 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40622 size_t arg2 ;
40623 int arg3 = (int) 0 ;
40624 PyObject * obj0 = 0 ;
40625 PyObject * obj1 = 0 ;
40626 PyObject * obj2 = 0 ;
40627 char *kwnames[] = {
40628 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40629 };
40630
40631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40633 if (SWIG_arg_fail(1)) SWIG_fail;
40634 {
40635 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40636 if (SWIG_arg_fail(2)) SWIG_fail;
40637 }
40638 if (obj2) {
40639 {
40640 arg3 = (int)(SWIG_As_int(obj2));
40641 if (SWIG_arg_fail(3)) SWIG_fail;
40642 }
40643 }
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 (arg1)->AddGrowableRow(arg2,arg3);
40647
40648 wxPyEndAllowThreads(__tstate);
40649 if (PyErr_Occurred()) SWIG_fail;
40650 }
40651 Py_INCREF(Py_None); resultobj = Py_None;
40652 return resultobj;
40653 fail:
40654 return NULL;
40655 }
40656
40657
40658 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40659 PyObject *resultobj;
40660 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40661 size_t arg2 ;
40662 PyObject * obj0 = 0 ;
40663 PyObject * obj1 = 0 ;
40664 char *kwnames[] = {
40665 (char *) "self",(char *) "idx", NULL
40666 };
40667
40668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40670 if (SWIG_arg_fail(1)) SWIG_fail;
40671 {
40672 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40673 if (SWIG_arg_fail(2)) SWIG_fail;
40674 }
40675 {
40676 PyThreadState* __tstate = wxPyBeginAllowThreads();
40677 (arg1)->RemoveGrowableRow(arg2);
40678
40679 wxPyEndAllowThreads(__tstate);
40680 if (PyErr_Occurred()) SWIG_fail;
40681 }
40682 Py_INCREF(Py_None); resultobj = Py_None;
40683 return resultobj;
40684 fail:
40685 return NULL;
40686 }
40687
40688
40689 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40690 PyObject *resultobj;
40691 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40692 size_t arg2 ;
40693 int arg3 = (int) 0 ;
40694 PyObject * obj0 = 0 ;
40695 PyObject * obj1 = 0 ;
40696 PyObject * obj2 = 0 ;
40697 char *kwnames[] = {
40698 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40699 };
40700
40701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40703 if (SWIG_arg_fail(1)) SWIG_fail;
40704 {
40705 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40706 if (SWIG_arg_fail(2)) SWIG_fail;
40707 }
40708 if (obj2) {
40709 {
40710 arg3 = (int)(SWIG_As_int(obj2));
40711 if (SWIG_arg_fail(3)) SWIG_fail;
40712 }
40713 }
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 (arg1)->AddGrowableCol(arg2,arg3);
40717
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 Py_INCREF(Py_None); resultobj = Py_None;
40722 return resultobj;
40723 fail:
40724 return NULL;
40725 }
40726
40727
40728 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40729 PyObject *resultobj;
40730 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40731 size_t arg2 ;
40732 PyObject * obj0 = 0 ;
40733 PyObject * obj1 = 0 ;
40734 char *kwnames[] = {
40735 (char *) "self",(char *) "idx", NULL
40736 };
40737
40738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40740 if (SWIG_arg_fail(1)) SWIG_fail;
40741 {
40742 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40743 if (SWIG_arg_fail(2)) SWIG_fail;
40744 }
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 (arg1)->RemoveGrowableCol(arg2);
40748
40749 wxPyEndAllowThreads(__tstate);
40750 if (PyErr_Occurred()) SWIG_fail;
40751 }
40752 Py_INCREF(Py_None); resultobj = Py_None;
40753 return resultobj;
40754 fail:
40755 return NULL;
40756 }
40757
40758
40759 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40760 PyObject *resultobj;
40761 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40762 int arg2 ;
40763 PyObject * obj0 = 0 ;
40764 PyObject * obj1 = 0 ;
40765 char *kwnames[] = {
40766 (char *) "self",(char *) "direction", NULL
40767 };
40768
40769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40771 if (SWIG_arg_fail(1)) SWIG_fail;
40772 {
40773 arg2 = (int)(SWIG_As_int(obj1));
40774 if (SWIG_arg_fail(2)) SWIG_fail;
40775 }
40776 {
40777 PyThreadState* __tstate = wxPyBeginAllowThreads();
40778 (arg1)->SetFlexibleDirection(arg2);
40779
40780 wxPyEndAllowThreads(__tstate);
40781 if (PyErr_Occurred()) SWIG_fail;
40782 }
40783 Py_INCREF(Py_None); resultobj = Py_None;
40784 return resultobj;
40785 fail:
40786 return NULL;
40787 }
40788
40789
40790 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40791 PyObject *resultobj;
40792 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40793 int result;
40794 PyObject * obj0 = 0 ;
40795 char *kwnames[] = {
40796 (char *) "self", NULL
40797 };
40798
40799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40801 if (SWIG_arg_fail(1)) SWIG_fail;
40802 {
40803 PyThreadState* __tstate = wxPyBeginAllowThreads();
40804 result = (int)(arg1)->GetFlexibleDirection();
40805
40806 wxPyEndAllowThreads(__tstate);
40807 if (PyErr_Occurred()) SWIG_fail;
40808 }
40809 {
40810 resultobj = SWIG_From_int((int)(result));
40811 }
40812 return resultobj;
40813 fail:
40814 return NULL;
40815 }
40816
40817
40818 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40819 PyObject *resultobj;
40820 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40821 wxFlexSizerGrowMode arg2 ;
40822 PyObject * obj0 = 0 ;
40823 PyObject * obj1 = 0 ;
40824 char *kwnames[] = {
40825 (char *) "self",(char *) "mode", NULL
40826 };
40827
40828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40830 if (SWIG_arg_fail(1)) SWIG_fail;
40831 {
40832 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40833 if (SWIG_arg_fail(2)) SWIG_fail;
40834 }
40835 {
40836 PyThreadState* __tstate = wxPyBeginAllowThreads();
40837 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40838
40839 wxPyEndAllowThreads(__tstate);
40840 if (PyErr_Occurred()) SWIG_fail;
40841 }
40842 Py_INCREF(Py_None); resultobj = Py_None;
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40850 PyObject *resultobj;
40851 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40852 wxFlexSizerGrowMode result;
40853 PyObject * obj0 = 0 ;
40854 char *kwnames[] = {
40855 (char *) "self", NULL
40856 };
40857
40858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40860 if (SWIG_arg_fail(1)) SWIG_fail;
40861 {
40862 PyThreadState* __tstate = wxPyBeginAllowThreads();
40863 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40864
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 resultobj = SWIG_From_int((result));
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40876 PyObject *resultobj;
40877 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40878 wxArrayInt *result;
40879 PyObject * obj0 = 0 ;
40880 char *kwnames[] = {
40881 (char *) "self", NULL
40882 };
40883
40884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40886 if (SWIG_arg_fail(1)) SWIG_fail;
40887 {
40888 PyThreadState* __tstate = wxPyBeginAllowThreads();
40889 {
40890 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40891 result = (wxArrayInt *) &_result_ref;
40892 }
40893
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = PyList_New(0);
40899 size_t idx;
40900 for (idx = 0; idx < result->GetCount(); idx += 1) {
40901 PyObject* val = PyInt_FromLong( result->Item(idx) );
40902 PyList_Append(resultobj, val);
40903 Py_DECREF(val);
40904 }
40905 }
40906 return resultobj;
40907 fail:
40908 return NULL;
40909 }
40910
40911
40912 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40913 PyObject *resultobj;
40914 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40915 wxArrayInt *result;
40916 PyObject * obj0 = 0 ;
40917 char *kwnames[] = {
40918 (char *) "self", NULL
40919 };
40920
40921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40923 if (SWIG_arg_fail(1)) SWIG_fail;
40924 {
40925 PyThreadState* __tstate = wxPyBeginAllowThreads();
40926 {
40927 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40928 result = (wxArrayInt *) &_result_ref;
40929 }
40930
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 {
40935 resultobj = PyList_New(0);
40936 size_t idx;
40937 for (idx = 0; idx < result->GetCount(); idx += 1) {
40938 PyObject* val = PyInt_FromLong( result->Item(idx) );
40939 PyList_Append(resultobj, val);
40940 Py_DECREF(val);
40941 }
40942 }
40943 return resultobj;
40944 fail:
40945 return NULL;
40946 }
40947
40948
40949 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40950 PyObject *obj;
40951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40952 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40953 Py_INCREF(obj);
40954 return Py_BuildValue((char *)"");
40955 }
40956 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40957 PyObject *resultobj;
40958 wxStdDialogButtonSizer *result;
40959 char *kwnames[] = {
40960 NULL
40961 };
40962
40963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40964 {
40965 PyThreadState* __tstate = wxPyBeginAllowThreads();
40966 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40967
40968 wxPyEndAllowThreads(__tstate);
40969 if (PyErr_Occurred()) SWIG_fail;
40970 }
40971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40972 return resultobj;
40973 fail:
40974 return NULL;
40975 }
40976
40977
40978 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40979 PyObject *resultobj;
40980 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40981 wxButton *arg2 = (wxButton *) 0 ;
40982 PyObject * obj0 = 0 ;
40983 PyObject * obj1 = 0 ;
40984 char *kwnames[] = {
40985 (char *) "self",(char *) "button", NULL
40986 };
40987
40988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40990 if (SWIG_arg_fail(1)) SWIG_fail;
40991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40992 if (SWIG_arg_fail(2)) SWIG_fail;
40993 {
40994 PyThreadState* __tstate = wxPyBeginAllowThreads();
40995 (arg1)->AddButton(arg2);
40996
40997 wxPyEndAllowThreads(__tstate);
40998 if (PyErr_Occurred()) SWIG_fail;
40999 }
41000 Py_INCREF(Py_None); resultobj = Py_None;
41001 return resultobj;
41002 fail:
41003 return NULL;
41004 }
41005
41006
41007 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41008 PyObject *resultobj;
41009 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41010 PyObject * obj0 = 0 ;
41011 char *kwnames[] = {
41012 (char *) "self", NULL
41013 };
41014
41015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41017 if (SWIG_arg_fail(1)) SWIG_fail;
41018 {
41019 PyThreadState* __tstate = wxPyBeginAllowThreads();
41020 (arg1)->Realize();
41021
41022 wxPyEndAllowThreads(__tstate);
41023 if (PyErr_Occurred()) SWIG_fail;
41024 }
41025 Py_INCREF(Py_None); resultobj = Py_None;
41026 return resultobj;
41027 fail:
41028 return NULL;
41029 }
41030
41031
41032 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41033 PyObject *resultobj;
41034 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41035 wxButton *arg2 = (wxButton *) 0 ;
41036 PyObject * obj0 = 0 ;
41037 PyObject * obj1 = 0 ;
41038 char *kwnames[] = {
41039 (char *) "self",(char *) "button", NULL
41040 };
41041
41042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41044 if (SWIG_arg_fail(1)) SWIG_fail;
41045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41046 if (SWIG_arg_fail(2)) SWIG_fail;
41047 {
41048 PyThreadState* __tstate = wxPyBeginAllowThreads();
41049 (arg1)->SetAffirmativeButton(arg2);
41050
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 Py_INCREF(Py_None); resultobj = Py_None;
41055 return resultobj;
41056 fail:
41057 return NULL;
41058 }
41059
41060
41061 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41062 PyObject *resultobj;
41063 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41064 wxButton *arg2 = (wxButton *) 0 ;
41065 PyObject * obj0 = 0 ;
41066 PyObject * obj1 = 0 ;
41067 char *kwnames[] = {
41068 (char *) "self",(char *) "button", NULL
41069 };
41070
41071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41073 if (SWIG_arg_fail(1)) SWIG_fail;
41074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41075 if (SWIG_arg_fail(2)) SWIG_fail;
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 (arg1)->SetNegativeButton(arg2);
41079
41080 wxPyEndAllowThreads(__tstate);
41081 if (PyErr_Occurred()) SWIG_fail;
41082 }
41083 Py_INCREF(Py_None); resultobj = Py_None;
41084 return resultobj;
41085 fail:
41086 return NULL;
41087 }
41088
41089
41090 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41091 PyObject *resultobj;
41092 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41093 wxButton *arg2 = (wxButton *) 0 ;
41094 PyObject * obj0 = 0 ;
41095 PyObject * obj1 = 0 ;
41096 char *kwnames[] = {
41097 (char *) "self",(char *) "button", NULL
41098 };
41099
41100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41102 if (SWIG_arg_fail(1)) SWIG_fail;
41103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41104 if (SWIG_arg_fail(2)) SWIG_fail;
41105 {
41106 PyThreadState* __tstate = wxPyBeginAllowThreads();
41107 (arg1)->SetCancelButton(arg2);
41108
41109 wxPyEndAllowThreads(__tstate);
41110 if (PyErr_Occurred()) SWIG_fail;
41111 }
41112 Py_INCREF(Py_None); resultobj = Py_None;
41113 return resultobj;
41114 fail:
41115 return NULL;
41116 }
41117
41118
41119 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj;
41121 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41122 wxButton *result;
41123 PyObject * obj0 = 0 ;
41124 char *kwnames[] = {
41125 (char *) "self", NULL
41126 };
41127
41128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41130 if (SWIG_arg_fail(1)) SWIG_fail;
41131 {
41132 PyThreadState* __tstate = wxPyBeginAllowThreads();
41133 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41134
41135 wxPyEndAllowThreads(__tstate);
41136 if (PyErr_Occurred()) SWIG_fail;
41137 }
41138 {
41139 resultobj = wxPyMake_wxObject(result, 0);
41140 }
41141 return resultobj;
41142 fail:
41143 return NULL;
41144 }
41145
41146
41147 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41148 PyObject *resultobj;
41149 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41150 wxButton *result;
41151 PyObject * obj0 = 0 ;
41152 char *kwnames[] = {
41153 (char *) "self", NULL
41154 };
41155
41156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41158 if (SWIG_arg_fail(1)) SWIG_fail;
41159 {
41160 PyThreadState* __tstate = wxPyBeginAllowThreads();
41161 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41162
41163 wxPyEndAllowThreads(__tstate);
41164 if (PyErr_Occurred()) SWIG_fail;
41165 }
41166 {
41167 resultobj = wxPyMake_wxObject(result, 0);
41168 }
41169 return resultobj;
41170 fail:
41171 return NULL;
41172 }
41173
41174
41175 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41176 PyObject *resultobj;
41177 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41178 wxButton *result;
41179 PyObject * obj0 = 0 ;
41180 char *kwnames[] = {
41181 (char *) "self", NULL
41182 };
41183
41184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41186 if (SWIG_arg_fail(1)) SWIG_fail;
41187 {
41188 PyThreadState* __tstate = wxPyBeginAllowThreads();
41189 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41190
41191 wxPyEndAllowThreads(__tstate);
41192 if (PyErr_Occurred()) SWIG_fail;
41193 }
41194 {
41195 resultobj = wxPyMake_wxObject(result, 0);
41196 }
41197 return resultobj;
41198 fail:
41199 return NULL;
41200 }
41201
41202
41203 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41204 PyObject *resultobj;
41205 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41206 wxButton *result;
41207 PyObject * obj0 = 0 ;
41208 char *kwnames[] = {
41209 (char *) "self", NULL
41210 };
41211
41212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41214 if (SWIG_arg_fail(1)) SWIG_fail;
41215 {
41216 PyThreadState* __tstate = wxPyBeginAllowThreads();
41217 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41218
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 {
41223 resultobj = wxPyMake_wxObject(result, 0);
41224 }
41225 return resultobj;
41226 fail:
41227 return NULL;
41228 }
41229
41230
41231 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41232 PyObject *resultobj;
41233 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41234 wxButton *result;
41235 PyObject * obj0 = 0 ;
41236 char *kwnames[] = {
41237 (char *) "self", NULL
41238 };
41239
41240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41242 if (SWIG_arg_fail(1)) SWIG_fail;
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41246
41247 wxPyEndAllowThreads(__tstate);
41248 if (PyErr_Occurred()) SWIG_fail;
41249 }
41250 {
41251 resultobj = wxPyMake_wxObject(result, 0);
41252 }
41253 return resultobj;
41254 fail:
41255 return NULL;
41256 }
41257
41258
41259 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41260 PyObject *obj;
41261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41262 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41263 Py_INCREF(obj);
41264 return Py_BuildValue((char *)"");
41265 }
41266 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41267 PyObject *resultobj;
41268 int arg1 = (int) 0 ;
41269 int arg2 = (int) 0 ;
41270 wxGBPosition *result;
41271 PyObject * obj0 = 0 ;
41272 PyObject * obj1 = 0 ;
41273 char *kwnames[] = {
41274 (char *) "row",(char *) "col", NULL
41275 };
41276
41277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41278 if (obj0) {
41279 {
41280 arg1 = (int)(SWIG_As_int(obj0));
41281 if (SWIG_arg_fail(1)) SWIG_fail;
41282 }
41283 }
41284 if (obj1) {
41285 {
41286 arg2 = (int)(SWIG_As_int(obj1));
41287 if (SWIG_arg_fail(2)) SWIG_fail;
41288 }
41289 }
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41293
41294 wxPyEndAllowThreads(__tstate);
41295 if (PyErr_Occurred()) SWIG_fail;
41296 }
41297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41298 return resultobj;
41299 fail:
41300 return NULL;
41301 }
41302
41303
41304 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41305 PyObject *resultobj;
41306 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41307 int result;
41308 PyObject * obj0 = 0 ;
41309 char *kwnames[] = {
41310 (char *) "self", NULL
41311 };
41312
41313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41315 if (SWIG_arg_fail(1)) SWIG_fail;
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 result = (int)((wxGBPosition const *)arg1)->GetRow();
41319
41320 wxPyEndAllowThreads(__tstate);
41321 if (PyErr_Occurred()) SWIG_fail;
41322 }
41323 {
41324 resultobj = SWIG_From_int((int)(result));
41325 }
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41333 PyObject *resultobj;
41334 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41335 int result;
41336 PyObject * obj0 = 0 ;
41337 char *kwnames[] = {
41338 (char *) "self", NULL
41339 };
41340
41341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41343 if (SWIG_arg_fail(1)) SWIG_fail;
41344 {
41345 PyThreadState* __tstate = wxPyBeginAllowThreads();
41346 result = (int)((wxGBPosition const *)arg1)->GetCol();
41347
41348 wxPyEndAllowThreads(__tstate);
41349 if (PyErr_Occurred()) SWIG_fail;
41350 }
41351 {
41352 resultobj = SWIG_From_int((int)(result));
41353 }
41354 return resultobj;
41355 fail:
41356 return NULL;
41357 }
41358
41359
41360 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41361 PyObject *resultobj;
41362 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41363 int arg2 ;
41364 PyObject * obj0 = 0 ;
41365 PyObject * obj1 = 0 ;
41366 char *kwnames[] = {
41367 (char *) "self",(char *) "row", NULL
41368 };
41369
41370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41372 if (SWIG_arg_fail(1)) SWIG_fail;
41373 {
41374 arg2 = (int)(SWIG_As_int(obj1));
41375 if (SWIG_arg_fail(2)) SWIG_fail;
41376 }
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 (arg1)->SetRow(arg2);
41380
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 Py_INCREF(Py_None); resultobj = Py_None;
41385 return resultobj;
41386 fail:
41387 return NULL;
41388 }
41389
41390
41391 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41392 PyObject *resultobj;
41393 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41394 int arg2 ;
41395 PyObject * obj0 = 0 ;
41396 PyObject * obj1 = 0 ;
41397 char *kwnames[] = {
41398 (char *) "self",(char *) "col", NULL
41399 };
41400
41401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41403 if (SWIG_arg_fail(1)) SWIG_fail;
41404 {
41405 arg2 = (int)(SWIG_As_int(obj1));
41406 if (SWIG_arg_fail(2)) SWIG_fail;
41407 }
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 (arg1)->SetCol(arg2);
41411
41412 wxPyEndAllowThreads(__tstate);
41413 if (PyErr_Occurred()) SWIG_fail;
41414 }
41415 Py_INCREF(Py_None); resultobj = Py_None;
41416 return resultobj;
41417 fail:
41418 return NULL;
41419 }
41420
41421
41422 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41423 PyObject *resultobj;
41424 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41425 wxGBPosition *arg2 = 0 ;
41426 bool result;
41427 wxGBPosition temp2 ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 char *kwnames[] = {
41431 (char *) "self",(char *) "other", NULL
41432 };
41433
41434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41436 if (SWIG_arg_fail(1)) SWIG_fail;
41437 {
41438 arg2 = &temp2;
41439 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41440 }
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 {
41449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41450 }
41451 return resultobj;
41452 fail:
41453 return NULL;
41454 }
41455
41456
41457 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41458 PyObject *resultobj;
41459 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41460 wxGBPosition *arg2 = 0 ;
41461 bool result;
41462 wxGBPosition temp2 ;
41463 PyObject * obj0 = 0 ;
41464 PyObject * obj1 = 0 ;
41465 char *kwnames[] = {
41466 (char *) "self",(char *) "other", NULL
41467 };
41468
41469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41471 if (SWIG_arg_fail(1)) SWIG_fail;
41472 {
41473 arg2 = &temp2;
41474 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41475 }
41476 {
41477 PyThreadState* __tstate = wxPyBeginAllowThreads();
41478 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41479
41480 wxPyEndAllowThreads(__tstate);
41481 if (PyErr_Occurred()) SWIG_fail;
41482 }
41483 {
41484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41485 }
41486 return resultobj;
41487 fail:
41488 return NULL;
41489 }
41490
41491
41492 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41493 PyObject *resultobj;
41494 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41495 int arg2 = (int) 0 ;
41496 int arg3 = (int) 0 ;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 PyObject * obj2 = 0 ;
41500 char *kwnames[] = {
41501 (char *) "self",(char *) "row",(char *) "col", NULL
41502 };
41503
41504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41506 if (SWIG_arg_fail(1)) SWIG_fail;
41507 if (obj1) {
41508 {
41509 arg2 = (int)(SWIG_As_int(obj1));
41510 if (SWIG_arg_fail(2)) SWIG_fail;
41511 }
41512 }
41513 if (obj2) {
41514 {
41515 arg3 = (int)(SWIG_As_int(obj2));
41516 if (SWIG_arg_fail(3)) SWIG_fail;
41517 }
41518 }
41519 {
41520 PyThreadState* __tstate = wxPyBeginAllowThreads();
41521 wxGBPosition_Set(arg1,arg2,arg3);
41522
41523 wxPyEndAllowThreads(__tstate);
41524 if (PyErr_Occurred()) SWIG_fail;
41525 }
41526 Py_INCREF(Py_None); resultobj = Py_None;
41527 return resultobj;
41528 fail:
41529 return NULL;
41530 }
41531
41532
41533 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41534 PyObject *resultobj;
41535 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41536 PyObject *result;
41537 PyObject * obj0 = 0 ;
41538 char *kwnames[] = {
41539 (char *) "self", NULL
41540 };
41541
41542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41544 if (SWIG_arg_fail(1)) SWIG_fail;
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 result = (PyObject *)wxGBPosition_Get(arg1);
41548
41549 wxPyEndAllowThreads(__tstate);
41550 if (PyErr_Occurred()) SWIG_fail;
41551 }
41552 resultobj = result;
41553 return resultobj;
41554 fail:
41555 return NULL;
41556 }
41557
41558
41559 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41560 PyObject *obj;
41561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41562 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41563 Py_INCREF(obj);
41564 return Py_BuildValue((char *)"");
41565 }
41566 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41567 PyObject *resultobj;
41568 int arg1 = (int) 1 ;
41569 int arg2 = (int) 1 ;
41570 wxGBSpan *result;
41571 PyObject * obj0 = 0 ;
41572 PyObject * obj1 = 0 ;
41573 char *kwnames[] = {
41574 (char *) "rowspan",(char *) "colspan", NULL
41575 };
41576
41577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41578 if (obj0) {
41579 {
41580 arg1 = (int)(SWIG_As_int(obj0));
41581 if (SWIG_arg_fail(1)) SWIG_fail;
41582 }
41583 }
41584 if (obj1) {
41585 {
41586 arg2 = (int)(SWIG_As_int(obj1));
41587 if (SWIG_arg_fail(2)) SWIG_fail;
41588 }
41589 }
41590 {
41591 PyThreadState* __tstate = wxPyBeginAllowThreads();
41592 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41593
41594 wxPyEndAllowThreads(__tstate);
41595 if (PyErr_Occurred()) SWIG_fail;
41596 }
41597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41598 return resultobj;
41599 fail:
41600 return NULL;
41601 }
41602
41603
41604 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41605 PyObject *resultobj;
41606 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41607 int result;
41608 PyObject * obj0 = 0 ;
41609 char *kwnames[] = {
41610 (char *) "self", NULL
41611 };
41612
41613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41615 if (SWIG_arg_fail(1)) SWIG_fail;
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41619
41620 wxPyEndAllowThreads(__tstate);
41621 if (PyErr_Occurred()) SWIG_fail;
41622 }
41623 {
41624 resultobj = SWIG_From_int((int)(result));
41625 }
41626 return resultobj;
41627 fail:
41628 return NULL;
41629 }
41630
41631
41632 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41633 PyObject *resultobj;
41634 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41635 int result;
41636 PyObject * obj0 = 0 ;
41637 char *kwnames[] = {
41638 (char *) "self", NULL
41639 };
41640
41641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41643 if (SWIG_arg_fail(1)) SWIG_fail;
41644 {
41645 PyThreadState* __tstate = wxPyBeginAllowThreads();
41646 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41647
41648 wxPyEndAllowThreads(__tstate);
41649 if (PyErr_Occurred()) SWIG_fail;
41650 }
41651 {
41652 resultobj = SWIG_From_int((int)(result));
41653 }
41654 return resultobj;
41655 fail:
41656 return NULL;
41657 }
41658
41659
41660 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41661 PyObject *resultobj;
41662 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41663 int arg2 ;
41664 PyObject * obj0 = 0 ;
41665 PyObject * obj1 = 0 ;
41666 char *kwnames[] = {
41667 (char *) "self",(char *) "rowspan", NULL
41668 };
41669
41670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41672 if (SWIG_arg_fail(1)) SWIG_fail;
41673 {
41674 arg2 = (int)(SWIG_As_int(obj1));
41675 if (SWIG_arg_fail(2)) SWIG_fail;
41676 }
41677 {
41678 PyThreadState* __tstate = wxPyBeginAllowThreads();
41679 (arg1)->SetRowspan(arg2);
41680
41681 wxPyEndAllowThreads(__tstate);
41682 if (PyErr_Occurred()) SWIG_fail;
41683 }
41684 Py_INCREF(Py_None); resultobj = Py_None;
41685 return resultobj;
41686 fail:
41687 return NULL;
41688 }
41689
41690
41691 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41692 PyObject *resultobj;
41693 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41694 int arg2 ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 char *kwnames[] = {
41698 (char *) "self",(char *) "colspan", NULL
41699 };
41700
41701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41703 if (SWIG_arg_fail(1)) SWIG_fail;
41704 {
41705 arg2 = (int)(SWIG_As_int(obj1));
41706 if (SWIG_arg_fail(2)) SWIG_fail;
41707 }
41708 {
41709 PyThreadState* __tstate = wxPyBeginAllowThreads();
41710 (arg1)->SetColspan(arg2);
41711
41712 wxPyEndAllowThreads(__tstate);
41713 if (PyErr_Occurred()) SWIG_fail;
41714 }
41715 Py_INCREF(Py_None); resultobj = Py_None;
41716 return resultobj;
41717 fail:
41718 return NULL;
41719 }
41720
41721
41722 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41723 PyObject *resultobj;
41724 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41725 wxGBSpan *arg2 = 0 ;
41726 bool result;
41727 wxGBSpan temp2 ;
41728 PyObject * obj0 = 0 ;
41729 PyObject * obj1 = 0 ;
41730 char *kwnames[] = {
41731 (char *) "self",(char *) "other", NULL
41732 };
41733
41734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41736 if (SWIG_arg_fail(1)) SWIG_fail;
41737 {
41738 arg2 = &temp2;
41739 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41740 }
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41744
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 {
41749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41750 }
41751 return resultobj;
41752 fail:
41753 return NULL;
41754 }
41755
41756
41757 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41758 PyObject *resultobj;
41759 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41760 wxGBSpan *arg2 = 0 ;
41761 bool result;
41762 wxGBSpan temp2 ;
41763 PyObject * obj0 = 0 ;
41764 PyObject * obj1 = 0 ;
41765 char *kwnames[] = {
41766 (char *) "self",(char *) "other", NULL
41767 };
41768
41769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41771 if (SWIG_arg_fail(1)) SWIG_fail;
41772 {
41773 arg2 = &temp2;
41774 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41775 }
41776 {
41777 PyThreadState* __tstate = wxPyBeginAllowThreads();
41778 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41779
41780 wxPyEndAllowThreads(__tstate);
41781 if (PyErr_Occurred()) SWIG_fail;
41782 }
41783 {
41784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41785 }
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41793 PyObject *resultobj;
41794 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41795 int arg2 = (int) 1 ;
41796 int arg3 = (int) 1 ;
41797 PyObject * obj0 = 0 ;
41798 PyObject * obj1 = 0 ;
41799 PyObject * obj2 = 0 ;
41800 char *kwnames[] = {
41801 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41802 };
41803
41804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41806 if (SWIG_arg_fail(1)) SWIG_fail;
41807 if (obj1) {
41808 {
41809 arg2 = (int)(SWIG_As_int(obj1));
41810 if (SWIG_arg_fail(2)) SWIG_fail;
41811 }
41812 }
41813 if (obj2) {
41814 {
41815 arg3 = (int)(SWIG_As_int(obj2));
41816 if (SWIG_arg_fail(3)) SWIG_fail;
41817 }
41818 }
41819 {
41820 PyThreadState* __tstate = wxPyBeginAllowThreads();
41821 wxGBSpan_Set(arg1,arg2,arg3);
41822
41823 wxPyEndAllowThreads(__tstate);
41824 if (PyErr_Occurred()) SWIG_fail;
41825 }
41826 Py_INCREF(Py_None); resultobj = Py_None;
41827 return resultobj;
41828 fail:
41829 return NULL;
41830 }
41831
41832
41833 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41834 PyObject *resultobj;
41835 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41836 PyObject *result;
41837 PyObject * obj0 = 0 ;
41838 char *kwnames[] = {
41839 (char *) "self", NULL
41840 };
41841
41842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41844 if (SWIG_arg_fail(1)) SWIG_fail;
41845 {
41846 PyThreadState* __tstate = wxPyBeginAllowThreads();
41847 result = (PyObject *)wxGBSpan_Get(arg1);
41848
41849 wxPyEndAllowThreads(__tstate);
41850 if (PyErr_Occurred()) SWIG_fail;
41851 }
41852 resultobj = result;
41853 return resultobj;
41854 fail:
41855 return NULL;
41856 }
41857
41858
41859 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41860 PyObject *obj;
41861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41862 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41863 Py_INCREF(obj);
41864 return Py_BuildValue((char *)"");
41865 }
41866 static int _wrap_DefaultSpan_set(PyObject *) {
41867 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41868 return 1;
41869 }
41870
41871
41872 static PyObject *_wrap_DefaultSpan_get(void) {
41873 PyObject *pyobj;
41874
41875 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41876 return pyobj;
41877 }
41878
41879
41880 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41881 PyObject *resultobj;
41882 wxGBSizerItem *result;
41883 char *kwnames[] = {
41884 NULL
41885 };
41886
41887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 result = (wxGBSizerItem *)new wxGBSizerItem();
41891
41892 wxPyEndAllowThreads(__tstate);
41893 if (PyErr_Occurred()) SWIG_fail;
41894 }
41895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41896 return resultobj;
41897 fail:
41898 return NULL;
41899 }
41900
41901
41902 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41903 PyObject *resultobj;
41904 wxWindow *arg1 = (wxWindow *) 0 ;
41905 wxGBPosition *arg2 = 0 ;
41906 wxGBSpan *arg3 = 0 ;
41907 int arg4 ;
41908 int arg5 ;
41909 PyObject *arg6 = (PyObject *) NULL ;
41910 wxGBSizerItem *result;
41911 wxGBPosition temp2 ;
41912 wxGBSpan temp3 ;
41913 PyObject * obj0 = 0 ;
41914 PyObject * obj1 = 0 ;
41915 PyObject * obj2 = 0 ;
41916 PyObject * obj3 = 0 ;
41917 PyObject * obj4 = 0 ;
41918 PyObject * obj5 = 0 ;
41919 char *kwnames[] = {
41920 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41921 };
41922
41923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41925 if (SWIG_arg_fail(1)) SWIG_fail;
41926 {
41927 arg2 = &temp2;
41928 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41929 }
41930 {
41931 arg3 = &temp3;
41932 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41933 }
41934 {
41935 arg4 = (int)(SWIG_As_int(obj3));
41936 if (SWIG_arg_fail(4)) SWIG_fail;
41937 }
41938 {
41939 arg5 = (int)(SWIG_As_int(obj4));
41940 if (SWIG_arg_fail(5)) SWIG_fail;
41941 }
41942 if (obj5) {
41943 arg6 = obj5;
41944 }
41945 {
41946 PyThreadState* __tstate = wxPyBeginAllowThreads();
41947 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41948
41949 wxPyEndAllowThreads(__tstate);
41950 if (PyErr_Occurred()) SWIG_fail;
41951 }
41952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41953 return resultobj;
41954 fail:
41955 return NULL;
41956 }
41957
41958
41959 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41960 PyObject *resultobj;
41961 wxSizer *arg1 = (wxSizer *) 0 ;
41962 wxGBPosition *arg2 = 0 ;
41963 wxGBSpan *arg3 = 0 ;
41964 int arg4 ;
41965 int arg5 ;
41966 PyObject *arg6 = (PyObject *) NULL ;
41967 wxGBSizerItem *result;
41968 wxGBPosition temp2 ;
41969 wxGBSpan temp3 ;
41970 PyObject * obj0 = 0 ;
41971 PyObject * obj1 = 0 ;
41972 PyObject * obj2 = 0 ;
41973 PyObject * obj3 = 0 ;
41974 PyObject * obj4 = 0 ;
41975 PyObject * obj5 = 0 ;
41976 char *kwnames[] = {
41977 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41978 };
41979
41980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41982 if (SWIG_arg_fail(1)) SWIG_fail;
41983 {
41984 arg2 = &temp2;
41985 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41986 }
41987 {
41988 arg3 = &temp3;
41989 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41990 }
41991 {
41992 arg4 = (int)(SWIG_As_int(obj3));
41993 if (SWIG_arg_fail(4)) SWIG_fail;
41994 }
41995 {
41996 arg5 = (int)(SWIG_As_int(obj4));
41997 if (SWIG_arg_fail(5)) SWIG_fail;
41998 }
41999 if (obj5) {
42000 arg6 = obj5;
42001 }
42002 {
42003 PyThreadState* __tstate = wxPyBeginAllowThreads();
42004 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42005
42006 wxPyEndAllowThreads(__tstate);
42007 if (PyErr_Occurred()) SWIG_fail;
42008 }
42009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42010 return resultobj;
42011 fail:
42012 return NULL;
42013 }
42014
42015
42016 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42017 PyObject *resultobj;
42018 int arg1 ;
42019 int arg2 ;
42020 wxGBPosition *arg3 = 0 ;
42021 wxGBSpan *arg4 = 0 ;
42022 int arg5 ;
42023 int arg6 ;
42024 PyObject *arg7 = (PyObject *) NULL ;
42025 wxGBSizerItem *result;
42026 wxGBPosition temp3 ;
42027 wxGBSpan temp4 ;
42028 PyObject * obj0 = 0 ;
42029 PyObject * obj1 = 0 ;
42030 PyObject * obj2 = 0 ;
42031 PyObject * obj3 = 0 ;
42032 PyObject * obj4 = 0 ;
42033 PyObject * obj5 = 0 ;
42034 PyObject * obj6 = 0 ;
42035 char *kwnames[] = {
42036 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42037 };
42038
42039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42040 {
42041 arg1 = (int)(SWIG_As_int(obj0));
42042 if (SWIG_arg_fail(1)) SWIG_fail;
42043 }
42044 {
42045 arg2 = (int)(SWIG_As_int(obj1));
42046 if (SWIG_arg_fail(2)) SWIG_fail;
42047 }
42048 {
42049 arg3 = &temp3;
42050 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42051 }
42052 {
42053 arg4 = &temp4;
42054 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42055 }
42056 {
42057 arg5 = (int)(SWIG_As_int(obj4));
42058 if (SWIG_arg_fail(5)) SWIG_fail;
42059 }
42060 {
42061 arg6 = (int)(SWIG_As_int(obj5));
42062 if (SWIG_arg_fail(6)) SWIG_fail;
42063 }
42064 if (obj6) {
42065 arg7 = obj6;
42066 }
42067 {
42068 PyThreadState* __tstate = wxPyBeginAllowThreads();
42069 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42070
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42075 return resultobj;
42076 fail:
42077 return NULL;
42078 }
42079
42080
42081 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42082 PyObject *resultobj;
42083 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42084 wxGBPosition result;
42085 PyObject * obj0 = 0 ;
42086 char *kwnames[] = {
42087 (char *) "self", NULL
42088 };
42089
42090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42092 if (SWIG_arg_fail(1)) SWIG_fail;
42093 {
42094 PyThreadState* __tstate = wxPyBeginAllowThreads();
42095 result = ((wxGBSizerItem const *)arg1)->GetPos();
42096
42097 wxPyEndAllowThreads(__tstate);
42098 if (PyErr_Occurred()) SWIG_fail;
42099 }
42100 {
42101 wxGBPosition * resultptr;
42102 resultptr = new wxGBPosition((wxGBPosition &)(result));
42103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42104 }
42105 return resultobj;
42106 fail:
42107 return NULL;
42108 }
42109
42110
42111 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42112 PyObject *resultobj;
42113 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42114 wxGBSpan result;
42115 PyObject * obj0 = 0 ;
42116 char *kwnames[] = {
42117 (char *) "self", NULL
42118 };
42119
42120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42122 if (SWIG_arg_fail(1)) SWIG_fail;
42123 {
42124 PyThreadState* __tstate = wxPyBeginAllowThreads();
42125 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42126
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 {
42131 wxGBSpan * resultptr;
42132 resultptr = new wxGBSpan((wxGBSpan &)(result));
42133 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42134 }
42135 return resultobj;
42136 fail:
42137 return NULL;
42138 }
42139
42140
42141 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42142 PyObject *resultobj;
42143 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42144 wxGBPosition *arg2 = 0 ;
42145 bool result;
42146 wxGBPosition temp2 ;
42147 PyObject * obj0 = 0 ;
42148 PyObject * obj1 = 0 ;
42149 char *kwnames[] = {
42150 (char *) "self",(char *) "pos", NULL
42151 };
42152
42153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42155 if (SWIG_arg_fail(1)) SWIG_fail;
42156 {
42157 arg2 = &temp2;
42158 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42159 }
42160 {
42161 PyThreadState* __tstate = wxPyBeginAllowThreads();
42162 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42163
42164 wxPyEndAllowThreads(__tstate);
42165 if (PyErr_Occurred()) SWIG_fail;
42166 }
42167 {
42168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42169 }
42170 return resultobj;
42171 fail:
42172 return NULL;
42173 }
42174
42175
42176 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42177 PyObject *resultobj;
42178 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42179 wxGBSpan *arg2 = 0 ;
42180 bool result;
42181 wxGBSpan temp2 ;
42182 PyObject * obj0 = 0 ;
42183 PyObject * obj1 = 0 ;
42184 char *kwnames[] = {
42185 (char *) "self",(char *) "span", NULL
42186 };
42187
42188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42190 if (SWIG_arg_fail(1)) SWIG_fail;
42191 {
42192 arg2 = &temp2;
42193 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42194 }
42195 {
42196 PyThreadState* __tstate = wxPyBeginAllowThreads();
42197 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42198
42199 wxPyEndAllowThreads(__tstate);
42200 if (PyErr_Occurred()) SWIG_fail;
42201 }
42202 {
42203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42204 }
42205 return resultobj;
42206 fail:
42207 return NULL;
42208 }
42209
42210
42211 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42212 PyObject *resultobj;
42213 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42214 wxGBSizerItem *arg2 = 0 ;
42215 bool result;
42216 PyObject * obj0 = 0 ;
42217 PyObject * obj1 = 0 ;
42218 char *kwnames[] = {
42219 (char *) "self",(char *) "other", NULL
42220 };
42221
42222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42224 if (SWIG_arg_fail(1)) SWIG_fail;
42225 {
42226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42227 if (SWIG_arg_fail(2)) SWIG_fail;
42228 if (arg2 == NULL) {
42229 SWIG_null_ref("wxGBSizerItem");
42230 }
42231 if (SWIG_arg_fail(2)) SWIG_fail;
42232 }
42233 {
42234 PyThreadState* __tstate = wxPyBeginAllowThreads();
42235 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42236
42237 wxPyEndAllowThreads(__tstate);
42238 if (PyErr_Occurred()) SWIG_fail;
42239 }
42240 {
42241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42242 }
42243 return resultobj;
42244 fail:
42245 return NULL;
42246 }
42247
42248
42249 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42250 PyObject *resultobj;
42251 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42252 wxGBPosition *arg2 = 0 ;
42253 wxGBSpan *arg3 = 0 ;
42254 bool result;
42255 wxGBPosition temp2 ;
42256 wxGBSpan temp3 ;
42257 PyObject * obj0 = 0 ;
42258 PyObject * obj1 = 0 ;
42259 PyObject * obj2 = 0 ;
42260 char *kwnames[] = {
42261 (char *) "self",(char *) "pos",(char *) "span", NULL
42262 };
42263
42264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42266 if (SWIG_arg_fail(1)) SWIG_fail;
42267 {
42268 arg2 = &temp2;
42269 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42270 }
42271 {
42272 arg3 = &temp3;
42273 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42274 }
42275 {
42276 PyThreadState* __tstate = wxPyBeginAllowThreads();
42277 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42278
42279 wxPyEndAllowThreads(__tstate);
42280 if (PyErr_Occurred()) SWIG_fail;
42281 }
42282 {
42283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42284 }
42285 return resultobj;
42286 fail:
42287 return NULL;
42288 }
42289
42290
42291 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42292 PyObject *resultobj;
42293 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42294 wxGBPosition result;
42295 PyObject * obj0 = 0 ;
42296 char *kwnames[] = {
42297 (char *) "self", NULL
42298 };
42299
42300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42302 if (SWIG_arg_fail(1)) SWIG_fail;
42303 {
42304 PyThreadState* __tstate = wxPyBeginAllowThreads();
42305 result = wxGBSizerItem_GetEndPos(arg1);
42306
42307 wxPyEndAllowThreads(__tstate);
42308 if (PyErr_Occurred()) SWIG_fail;
42309 }
42310 {
42311 wxGBPosition * resultptr;
42312 resultptr = new wxGBPosition((wxGBPosition &)(result));
42313 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42314 }
42315 return resultobj;
42316 fail:
42317 return NULL;
42318 }
42319
42320
42321 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42322 PyObject *resultobj;
42323 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42324 wxGridBagSizer *result;
42325 PyObject * obj0 = 0 ;
42326 char *kwnames[] = {
42327 (char *) "self", NULL
42328 };
42329
42330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42332 if (SWIG_arg_fail(1)) SWIG_fail;
42333 {
42334 PyThreadState* __tstate = wxPyBeginAllowThreads();
42335 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42336
42337 wxPyEndAllowThreads(__tstate);
42338 if (PyErr_Occurred()) SWIG_fail;
42339 }
42340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42341 return resultobj;
42342 fail:
42343 return NULL;
42344 }
42345
42346
42347 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42348 PyObject *resultobj;
42349 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42350 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42351 PyObject * obj0 = 0 ;
42352 PyObject * obj1 = 0 ;
42353 char *kwnames[] = {
42354 (char *) "self",(char *) "sizer", NULL
42355 };
42356
42357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42359 if (SWIG_arg_fail(1)) SWIG_fail;
42360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42361 if (SWIG_arg_fail(2)) SWIG_fail;
42362 {
42363 PyThreadState* __tstate = wxPyBeginAllowThreads();
42364 (arg1)->SetGBSizer(arg2);
42365
42366 wxPyEndAllowThreads(__tstate);
42367 if (PyErr_Occurred()) SWIG_fail;
42368 }
42369 Py_INCREF(Py_None); resultobj = Py_None;
42370 return resultobj;
42371 fail:
42372 return NULL;
42373 }
42374
42375
42376 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42377 PyObject *obj;
42378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42379 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42380 Py_INCREF(obj);
42381 return Py_BuildValue((char *)"");
42382 }
42383 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42384 PyObject *resultobj;
42385 int arg1 = (int) 0 ;
42386 int arg2 = (int) 0 ;
42387 wxGridBagSizer *result;
42388 PyObject * obj0 = 0 ;
42389 PyObject * obj1 = 0 ;
42390 char *kwnames[] = {
42391 (char *) "vgap",(char *) "hgap", NULL
42392 };
42393
42394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42395 if (obj0) {
42396 {
42397 arg1 = (int)(SWIG_As_int(obj0));
42398 if (SWIG_arg_fail(1)) SWIG_fail;
42399 }
42400 }
42401 if (obj1) {
42402 {
42403 arg2 = (int)(SWIG_As_int(obj1));
42404 if (SWIG_arg_fail(2)) SWIG_fail;
42405 }
42406 }
42407 {
42408 PyThreadState* __tstate = wxPyBeginAllowThreads();
42409 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42410
42411 wxPyEndAllowThreads(__tstate);
42412 if (PyErr_Occurred()) SWIG_fail;
42413 }
42414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42415 return resultobj;
42416 fail:
42417 return NULL;
42418 }
42419
42420
42421 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42422 PyObject *resultobj;
42423 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42424 PyObject *arg2 = (PyObject *) 0 ;
42425 wxGBPosition *arg3 = 0 ;
42426 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42427 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42428 int arg5 = (int) 0 ;
42429 int arg6 = (int) 0 ;
42430 PyObject *arg7 = (PyObject *) NULL ;
42431 wxGBSizerItem *result;
42432 wxGBPosition temp3 ;
42433 wxGBSpan temp4 ;
42434 PyObject * obj0 = 0 ;
42435 PyObject * obj1 = 0 ;
42436 PyObject * obj2 = 0 ;
42437 PyObject * obj3 = 0 ;
42438 PyObject * obj4 = 0 ;
42439 PyObject * obj5 = 0 ;
42440 PyObject * obj6 = 0 ;
42441 char *kwnames[] = {
42442 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42443 };
42444
42445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42447 if (SWIG_arg_fail(1)) SWIG_fail;
42448 arg2 = obj1;
42449 {
42450 arg3 = &temp3;
42451 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42452 }
42453 if (obj3) {
42454 {
42455 arg4 = &temp4;
42456 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42457 }
42458 }
42459 if (obj4) {
42460 {
42461 arg5 = (int)(SWIG_As_int(obj4));
42462 if (SWIG_arg_fail(5)) SWIG_fail;
42463 }
42464 }
42465 if (obj5) {
42466 {
42467 arg6 = (int)(SWIG_As_int(obj5));
42468 if (SWIG_arg_fail(6)) SWIG_fail;
42469 }
42470 }
42471 if (obj6) {
42472 arg7 = obj6;
42473 }
42474 {
42475 PyThreadState* __tstate = wxPyBeginAllowThreads();
42476 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42477
42478 wxPyEndAllowThreads(__tstate);
42479 if (PyErr_Occurred()) SWIG_fail;
42480 }
42481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42482 return resultobj;
42483 fail:
42484 return NULL;
42485 }
42486
42487
42488 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42489 PyObject *resultobj;
42490 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42491 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42492 wxGBSizerItem *result;
42493 PyObject * obj0 = 0 ;
42494 PyObject * obj1 = 0 ;
42495 char *kwnames[] = {
42496 (char *) "self",(char *) "item", NULL
42497 };
42498
42499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42501 if (SWIG_arg_fail(1)) SWIG_fail;
42502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42503 if (SWIG_arg_fail(2)) SWIG_fail;
42504 {
42505 PyThreadState* __tstate = wxPyBeginAllowThreads();
42506 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42507
42508 wxPyEndAllowThreads(__tstate);
42509 if (PyErr_Occurred()) SWIG_fail;
42510 }
42511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42512 return resultobj;
42513 fail:
42514 return NULL;
42515 }
42516
42517
42518 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42519 PyObject *resultobj;
42520 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42521 int arg2 ;
42522 int arg3 ;
42523 wxSize result;
42524 PyObject * obj0 = 0 ;
42525 PyObject * obj1 = 0 ;
42526 PyObject * obj2 = 0 ;
42527 char *kwnames[] = {
42528 (char *) "self",(char *) "row",(char *) "col", NULL
42529 };
42530
42531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42533 if (SWIG_arg_fail(1)) SWIG_fail;
42534 {
42535 arg2 = (int)(SWIG_As_int(obj1));
42536 if (SWIG_arg_fail(2)) SWIG_fail;
42537 }
42538 {
42539 arg3 = (int)(SWIG_As_int(obj2));
42540 if (SWIG_arg_fail(3)) SWIG_fail;
42541 }
42542 {
42543 PyThreadState* __tstate = wxPyBeginAllowThreads();
42544 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42545
42546 wxPyEndAllowThreads(__tstate);
42547 if (PyErr_Occurred()) SWIG_fail;
42548 }
42549 {
42550 wxSize * resultptr;
42551 resultptr = new wxSize((wxSize &)(result));
42552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42553 }
42554 return resultobj;
42555 fail:
42556 return NULL;
42557 }
42558
42559
42560 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42561 PyObject *resultobj;
42562 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42563 wxSize result;
42564 PyObject * obj0 = 0 ;
42565 char *kwnames[] = {
42566 (char *) "self", NULL
42567 };
42568
42569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42571 if (SWIG_arg_fail(1)) SWIG_fail;
42572 {
42573 PyThreadState* __tstate = wxPyBeginAllowThreads();
42574 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42575
42576 wxPyEndAllowThreads(__tstate);
42577 if (PyErr_Occurred()) SWIG_fail;
42578 }
42579 {
42580 wxSize * resultptr;
42581 resultptr = new wxSize((wxSize &)(result));
42582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42583 }
42584 return resultobj;
42585 fail:
42586 return NULL;
42587 }
42588
42589
42590 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42591 PyObject *resultobj;
42592 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42593 wxSize *arg2 = 0 ;
42594 wxSize temp2 ;
42595 PyObject * obj0 = 0 ;
42596 PyObject * obj1 = 0 ;
42597 char *kwnames[] = {
42598 (char *) "self",(char *) "sz", NULL
42599 };
42600
42601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42603 if (SWIG_arg_fail(1)) SWIG_fail;
42604 {
42605 arg2 = &temp2;
42606 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42607 }
42608 {
42609 PyThreadState* __tstate = wxPyBeginAllowThreads();
42610 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42611
42612 wxPyEndAllowThreads(__tstate);
42613 if (PyErr_Occurred()) SWIG_fail;
42614 }
42615 Py_INCREF(Py_None); resultobj = Py_None;
42616 return resultobj;
42617 fail:
42618 return NULL;
42619 }
42620
42621
42622 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42623 PyObject *resultobj;
42624 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42625 wxWindow *arg2 = (wxWindow *) 0 ;
42626 wxGBPosition result;
42627 PyObject * obj0 = 0 ;
42628 PyObject * obj1 = 0 ;
42629
42630 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42632 if (SWIG_arg_fail(1)) SWIG_fail;
42633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42634 if (SWIG_arg_fail(2)) SWIG_fail;
42635 {
42636 PyThreadState* __tstate = wxPyBeginAllowThreads();
42637 result = (arg1)->GetItemPosition(arg2);
42638
42639 wxPyEndAllowThreads(__tstate);
42640 if (PyErr_Occurred()) SWIG_fail;
42641 }
42642 {
42643 wxGBPosition * resultptr;
42644 resultptr = new wxGBPosition((wxGBPosition &)(result));
42645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42646 }
42647 return resultobj;
42648 fail:
42649 return NULL;
42650 }
42651
42652
42653 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42654 PyObject *resultobj;
42655 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42656 wxSizer *arg2 = (wxSizer *) 0 ;
42657 wxGBPosition result;
42658 PyObject * obj0 = 0 ;
42659 PyObject * obj1 = 0 ;
42660
42661 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42663 if (SWIG_arg_fail(1)) SWIG_fail;
42664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42665 if (SWIG_arg_fail(2)) SWIG_fail;
42666 {
42667 PyThreadState* __tstate = wxPyBeginAllowThreads();
42668 result = (arg1)->GetItemPosition(arg2);
42669
42670 wxPyEndAllowThreads(__tstate);
42671 if (PyErr_Occurred()) SWIG_fail;
42672 }
42673 {
42674 wxGBPosition * resultptr;
42675 resultptr = new wxGBPosition((wxGBPosition &)(result));
42676 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42677 }
42678 return resultobj;
42679 fail:
42680 return NULL;
42681 }
42682
42683
42684 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42685 PyObject *resultobj;
42686 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42687 size_t arg2 ;
42688 wxGBPosition result;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691
42692 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42694 if (SWIG_arg_fail(1)) SWIG_fail;
42695 {
42696 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42697 if (SWIG_arg_fail(2)) SWIG_fail;
42698 }
42699 {
42700 PyThreadState* __tstate = wxPyBeginAllowThreads();
42701 result = (arg1)->GetItemPosition(arg2);
42702
42703 wxPyEndAllowThreads(__tstate);
42704 if (PyErr_Occurred()) SWIG_fail;
42705 }
42706 {
42707 wxGBPosition * resultptr;
42708 resultptr = new wxGBPosition((wxGBPosition &)(result));
42709 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42710 }
42711 return resultobj;
42712 fail:
42713 return NULL;
42714 }
42715
42716
42717 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42718 int argc;
42719 PyObject *argv[3];
42720 int ii;
42721
42722 argc = PyObject_Length(args);
42723 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42724 argv[ii] = PyTuple_GetItem(args,ii);
42725 }
42726 if (argc == 2) {
42727 int _v;
42728 {
42729 void *ptr;
42730 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42731 _v = 0;
42732 PyErr_Clear();
42733 } else {
42734 _v = 1;
42735 }
42736 }
42737 if (_v) {
42738 {
42739 void *ptr;
42740 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42741 _v = 0;
42742 PyErr_Clear();
42743 } else {
42744 _v = 1;
42745 }
42746 }
42747 if (_v) {
42748 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42749 }
42750 }
42751 }
42752 if (argc == 2) {
42753 int _v;
42754 {
42755 void *ptr;
42756 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42757 _v = 0;
42758 PyErr_Clear();
42759 } else {
42760 _v = 1;
42761 }
42762 }
42763 if (_v) {
42764 {
42765 void *ptr;
42766 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42767 _v = 0;
42768 PyErr_Clear();
42769 } else {
42770 _v = 1;
42771 }
42772 }
42773 if (_v) {
42774 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42775 }
42776 }
42777 }
42778 if (argc == 2) {
42779 int _v;
42780 {
42781 void *ptr;
42782 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42783 _v = 0;
42784 PyErr_Clear();
42785 } else {
42786 _v = 1;
42787 }
42788 }
42789 if (_v) {
42790 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42791 if (_v) {
42792 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42793 }
42794 }
42795 }
42796
42797 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42798 return NULL;
42799 }
42800
42801
42802 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42803 PyObject *resultobj;
42804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42805 wxWindow *arg2 = (wxWindow *) 0 ;
42806 wxGBPosition *arg3 = 0 ;
42807 bool result;
42808 wxGBPosition temp3 ;
42809 PyObject * obj0 = 0 ;
42810 PyObject * obj1 = 0 ;
42811 PyObject * obj2 = 0 ;
42812
42813 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42815 if (SWIG_arg_fail(1)) SWIG_fail;
42816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42817 if (SWIG_arg_fail(2)) SWIG_fail;
42818 {
42819 arg3 = &temp3;
42820 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42821 }
42822 {
42823 PyThreadState* __tstate = wxPyBeginAllowThreads();
42824 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42825
42826 wxPyEndAllowThreads(__tstate);
42827 if (PyErr_Occurred()) SWIG_fail;
42828 }
42829 {
42830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42831 }
42832 return resultobj;
42833 fail:
42834 return NULL;
42835 }
42836
42837
42838 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42839 PyObject *resultobj;
42840 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42841 wxSizer *arg2 = (wxSizer *) 0 ;
42842 wxGBPosition *arg3 = 0 ;
42843 bool result;
42844 wxGBPosition temp3 ;
42845 PyObject * obj0 = 0 ;
42846 PyObject * obj1 = 0 ;
42847 PyObject * obj2 = 0 ;
42848
42849 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42851 if (SWIG_arg_fail(1)) SWIG_fail;
42852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42853 if (SWIG_arg_fail(2)) SWIG_fail;
42854 {
42855 arg3 = &temp3;
42856 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42857 }
42858 {
42859 PyThreadState* __tstate = wxPyBeginAllowThreads();
42860 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42861
42862 wxPyEndAllowThreads(__tstate);
42863 if (PyErr_Occurred()) SWIG_fail;
42864 }
42865 {
42866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42867 }
42868 return resultobj;
42869 fail:
42870 return NULL;
42871 }
42872
42873
42874 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42875 PyObject *resultobj;
42876 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42877 size_t arg2 ;
42878 wxGBPosition *arg3 = 0 ;
42879 bool result;
42880 wxGBPosition temp3 ;
42881 PyObject * obj0 = 0 ;
42882 PyObject * obj1 = 0 ;
42883 PyObject * obj2 = 0 ;
42884
42885 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42887 if (SWIG_arg_fail(1)) SWIG_fail;
42888 {
42889 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42890 if (SWIG_arg_fail(2)) SWIG_fail;
42891 }
42892 {
42893 arg3 = &temp3;
42894 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42895 }
42896 {
42897 PyThreadState* __tstate = wxPyBeginAllowThreads();
42898 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42899
42900 wxPyEndAllowThreads(__tstate);
42901 if (PyErr_Occurred()) SWIG_fail;
42902 }
42903 {
42904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42905 }
42906 return resultobj;
42907 fail:
42908 return NULL;
42909 }
42910
42911
42912 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42913 int argc;
42914 PyObject *argv[4];
42915 int ii;
42916
42917 argc = PyObject_Length(args);
42918 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42919 argv[ii] = PyTuple_GetItem(args,ii);
42920 }
42921 if (argc == 3) {
42922 int _v;
42923 {
42924 void *ptr;
42925 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42926 _v = 0;
42927 PyErr_Clear();
42928 } else {
42929 _v = 1;
42930 }
42931 }
42932 if (_v) {
42933 {
42934 void *ptr;
42935 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42936 _v = 0;
42937 PyErr_Clear();
42938 } else {
42939 _v = 1;
42940 }
42941 }
42942 if (_v) {
42943 {
42944 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42945 }
42946 if (_v) {
42947 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42948 }
42949 }
42950 }
42951 }
42952 if (argc == 3) {
42953 int _v;
42954 {
42955 void *ptr;
42956 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42957 _v = 0;
42958 PyErr_Clear();
42959 } else {
42960 _v = 1;
42961 }
42962 }
42963 if (_v) {
42964 {
42965 void *ptr;
42966 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42967 _v = 0;
42968 PyErr_Clear();
42969 } else {
42970 _v = 1;
42971 }
42972 }
42973 if (_v) {
42974 {
42975 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42976 }
42977 if (_v) {
42978 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42979 }
42980 }
42981 }
42982 }
42983 if (argc == 3) {
42984 int _v;
42985 {
42986 void *ptr;
42987 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42988 _v = 0;
42989 PyErr_Clear();
42990 } else {
42991 _v = 1;
42992 }
42993 }
42994 if (_v) {
42995 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42996 if (_v) {
42997 {
42998 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42999 }
43000 if (_v) {
43001 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43002 }
43003 }
43004 }
43005 }
43006
43007 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43008 return NULL;
43009 }
43010
43011
43012 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43013 PyObject *resultobj;
43014 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43015 wxWindow *arg2 = (wxWindow *) 0 ;
43016 wxGBSpan result;
43017 PyObject * obj0 = 0 ;
43018 PyObject * obj1 = 0 ;
43019
43020 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43022 if (SWIG_arg_fail(1)) SWIG_fail;
43023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43024 if (SWIG_arg_fail(2)) SWIG_fail;
43025 {
43026 PyThreadState* __tstate = wxPyBeginAllowThreads();
43027 result = (arg1)->GetItemSpan(arg2);
43028
43029 wxPyEndAllowThreads(__tstate);
43030 if (PyErr_Occurred()) SWIG_fail;
43031 }
43032 {
43033 wxGBSpan * resultptr;
43034 resultptr = new wxGBSpan((wxGBSpan &)(result));
43035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43036 }
43037 return resultobj;
43038 fail:
43039 return NULL;
43040 }
43041
43042
43043 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43044 PyObject *resultobj;
43045 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43046 wxSizer *arg2 = (wxSizer *) 0 ;
43047 wxGBSpan result;
43048 PyObject * obj0 = 0 ;
43049 PyObject * obj1 = 0 ;
43050
43051 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43055 if (SWIG_arg_fail(2)) SWIG_fail;
43056 {
43057 PyThreadState* __tstate = wxPyBeginAllowThreads();
43058 result = (arg1)->GetItemSpan(arg2);
43059
43060 wxPyEndAllowThreads(__tstate);
43061 if (PyErr_Occurred()) SWIG_fail;
43062 }
43063 {
43064 wxGBSpan * resultptr;
43065 resultptr = new wxGBSpan((wxGBSpan &)(result));
43066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43067 }
43068 return resultobj;
43069 fail:
43070 return NULL;
43071 }
43072
43073
43074 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43075 PyObject *resultobj;
43076 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43077 size_t arg2 ;
43078 wxGBSpan result;
43079 PyObject * obj0 = 0 ;
43080 PyObject * obj1 = 0 ;
43081
43082 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43084 if (SWIG_arg_fail(1)) SWIG_fail;
43085 {
43086 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43087 if (SWIG_arg_fail(2)) SWIG_fail;
43088 }
43089 {
43090 PyThreadState* __tstate = wxPyBeginAllowThreads();
43091 result = (arg1)->GetItemSpan(arg2);
43092
43093 wxPyEndAllowThreads(__tstate);
43094 if (PyErr_Occurred()) SWIG_fail;
43095 }
43096 {
43097 wxGBSpan * resultptr;
43098 resultptr = new wxGBSpan((wxGBSpan &)(result));
43099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43100 }
43101 return resultobj;
43102 fail:
43103 return NULL;
43104 }
43105
43106
43107 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43108 int argc;
43109 PyObject *argv[3];
43110 int ii;
43111
43112 argc = PyObject_Length(args);
43113 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43114 argv[ii] = PyTuple_GetItem(args,ii);
43115 }
43116 if (argc == 2) {
43117 int _v;
43118 {
43119 void *ptr;
43120 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43121 _v = 0;
43122 PyErr_Clear();
43123 } else {
43124 _v = 1;
43125 }
43126 }
43127 if (_v) {
43128 {
43129 void *ptr;
43130 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43131 _v = 0;
43132 PyErr_Clear();
43133 } else {
43134 _v = 1;
43135 }
43136 }
43137 if (_v) {
43138 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43139 }
43140 }
43141 }
43142 if (argc == 2) {
43143 int _v;
43144 {
43145 void *ptr;
43146 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43147 _v = 0;
43148 PyErr_Clear();
43149 } else {
43150 _v = 1;
43151 }
43152 }
43153 if (_v) {
43154 {
43155 void *ptr;
43156 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43157 _v = 0;
43158 PyErr_Clear();
43159 } else {
43160 _v = 1;
43161 }
43162 }
43163 if (_v) {
43164 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43165 }
43166 }
43167 }
43168 if (argc == 2) {
43169 int _v;
43170 {
43171 void *ptr;
43172 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43173 _v = 0;
43174 PyErr_Clear();
43175 } else {
43176 _v = 1;
43177 }
43178 }
43179 if (_v) {
43180 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43181 if (_v) {
43182 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43183 }
43184 }
43185 }
43186
43187 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43188 return NULL;
43189 }
43190
43191
43192 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43193 PyObject *resultobj;
43194 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43195 wxWindow *arg2 = (wxWindow *) 0 ;
43196 wxGBSpan *arg3 = 0 ;
43197 bool result;
43198 wxGBSpan temp3 ;
43199 PyObject * obj0 = 0 ;
43200 PyObject * obj1 = 0 ;
43201 PyObject * obj2 = 0 ;
43202
43203 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43205 if (SWIG_arg_fail(1)) SWIG_fail;
43206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43207 if (SWIG_arg_fail(2)) SWIG_fail;
43208 {
43209 arg3 = &temp3;
43210 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43211 }
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43215
43216 wxPyEndAllowThreads(__tstate);
43217 if (PyErr_Occurred()) SWIG_fail;
43218 }
43219 {
43220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43221 }
43222 return resultobj;
43223 fail:
43224 return NULL;
43225 }
43226
43227
43228 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43229 PyObject *resultobj;
43230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43231 wxSizer *arg2 = (wxSizer *) 0 ;
43232 wxGBSpan *arg3 = 0 ;
43233 bool result;
43234 wxGBSpan temp3 ;
43235 PyObject * obj0 = 0 ;
43236 PyObject * obj1 = 0 ;
43237 PyObject * obj2 = 0 ;
43238
43239 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43241 if (SWIG_arg_fail(1)) SWIG_fail;
43242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43243 if (SWIG_arg_fail(2)) SWIG_fail;
43244 {
43245 arg3 = &temp3;
43246 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43247 }
43248 {
43249 PyThreadState* __tstate = wxPyBeginAllowThreads();
43250 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43251
43252 wxPyEndAllowThreads(__tstate);
43253 if (PyErr_Occurred()) SWIG_fail;
43254 }
43255 {
43256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43257 }
43258 return resultobj;
43259 fail:
43260 return NULL;
43261 }
43262
43263
43264 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43265 PyObject *resultobj;
43266 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43267 size_t arg2 ;
43268 wxGBSpan *arg3 = 0 ;
43269 bool result;
43270 wxGBSpan temp3 ;
43271 PyObject * obj0 = 0 ;
43272 PyObject * obj1 = 0 ;
43273 PyObject * obj2 = 0 ;
43274
43275 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43277 if (SWIG_arg_fail(1)) SWIG_fail;
43278 {
43279 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43280 if (SWIG_arg_fail(2)) SWIG_fail;
43281 }
43282 {
43283 arg3 = &temp3;
43284 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43285 }
43286 {
43287 PyThreadState* __tstate = wxPyBeginAllowThreads();
43288 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43289
43290 wxPyEndAllowThreads(__tstate);
43291 if (PyErr_Occurred()) SWIG_fail;
43292 }
43293 {
43294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43295 }
43296 return resultobj;
43297 fail:
43298 return NULL;
43299 }
43300
43301
43302 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43303 int argc;
43304 PyObject *argv[4];
43305 int ii;
43306
43307 argc = PyObject_Length(args);
43308 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43309 argv[ii] = PyTuple_GetItem(args,ii);
43310 }
43311 if (argc == 3) {
43312 int _v;
43313 {
43314 void *ptr;
43315 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43316 _v = 0;
43317 PyErr_Clear();
43318 } else {
43319 _v = 1;
43320 }
43321 }
43322 if (_v) {
43323 {
43324 void *ptr;
43325 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43326 _v = 0;
43327 PyErr_Clear();
43328 } else {
43329 _v = 1;
43330 }
43331 }
43332 if (_v) {
43333 {
43334 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43335 }
43336 if (_v) {
43337 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43338 }
43339 }
43340 }
43341 }
43342 if (argc == 3) {
43343 int _v;
43344 {
43345 void *ptr;
43346 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43347 _v = 0;
43348 PyErr_Clear();
43349 } else {
43350 _v = 1;
43351 }
43352 }
43353 if (_v) {
43354 {
43355 void *ptr;
43356 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43357 _v = 0;
43358 PyErr_Clear();
43359 } else {
43360 _v = 1;
43361 }
43362 }
43363 if (_v) {
43364 {
43365 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43366 }
43367 if (_v) {
43368 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43369 }
43370 }
43371 }
43372 }
43373 if (argc == 3) {
43374 int _v;
43375 {
43376 void *ptr;
43377 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43378 _v = 0;
43379 PyErr_Clear();
43380 } else {
43381 _v = 1;
43382 }
43383 }
43384 if (_v) {
43385 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43386 if (_v) {
43387 {
43388 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43389 }
43390 if (_v) {
43391 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43392 }
43393 }
43394 }
43395 }
43396
43397 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43398 return NULL;
43399 }
43400
43401
43402 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43403 PyObject *resultobj;
43404 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43405 wxWindow *arg2 = (wxWindow *) 0 ;
43406 wxGBSizerItem *result;
43407 PyObject * obj0 = 0 ;
43408 PyObject * obj1 = 0 ;
43409
43410 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43412 if (SWIG_arg_fail(1)) SWIG_fail;
43413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43414 if (SWIG_arg_fail(2)) SWIG_fail;
43415 {
43416 PyThreadState* __tstate = wxPyBeginAllowThreads();
43417 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43418
43419 wxPyEndAllowThreads(__tstate);
43420 if (PyErr_Occurred()) SWIG_fail;
43421 }
43422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43423 return resultobj;
43424 fail:
43425 return NULL;
43426 }
43427
43428
43429 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43430 PyObject *resultobj;
43431 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43432 wxSizer *arg2 = (wxSizer *) 0 ;
43433 wxGBSizerItem *result;
43434 PyObject * obj0 = 0 ;
43435 PyObject * obj1 = 0 ;
43436
43437 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43439 if (SWIG_arg_fail(1)) SWIG_fail;
43440 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43441 if (SWIG_arg_fail(2)) SWIG_fail;
43442 {
43443 PyThreadState* __tstate = wxPyBeginAllowThreads();
43444 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43445
43446 wxPyEndAllowThreads(__tstate);
43447 if (PyErr_Occurred()) SWIG_fail;
43448 }
43449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43450 return resultobj;
43451 fail:
43452 return NULL;
43453 }
43454
43455
43456 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43457 int argc;
43458 PyObject *argv[3];
43459 int ii;
43460
43461 argc = PyObject_Length(args);
43462 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43463 argv[ii] = PyTuple_GetItem(args,ii);
43464 }
43465 if (argc == 2) {
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 {
43478 void *ptr;
43479 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43480 _v = 0;
43481 PyErr_Clear();
43482 } else {
43483 _v = 1;
43484 }
43485 }
43486 if (_v) {
43487 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43488 }
43489 }
43490 }
43491 if (argc == 2) {
43492 int _v;
43493 {
43494 void *ptr;
43495 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43496 _v = 0;
43497 PyErr_Clear();
43498 } else {
43499 _v = 1;
43500 }
43501 }
43502 if (_v) {
43503 {
43504 void *ptr;
43505 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43506 _v = 0;
43507 PyErr_Clear();
43508 } else {
43509 _v = 1;
43510 }
43511 }
43512 if (_v) {
43513 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43514 }
43515 }
43516 }
43517
43518 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43519 return NULL;
43520 }
43521
43522
43523 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43524 PyObject *resultobj;
43525 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43526 wxGBPosition *arg2 = 0 ;
43527 wxGBSizerItem *result;
43528 wxGBPosition temp2 ;
43529 PyObject * obj0 = 0 ;
43530 PyObject * obj1 = 0 ;
43531 char *kwnames[] = {
43532 (char *) "self",(char *) "pos", NULL
43533 };
43534
43535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43537 if (SWIG_arg_fail(1)) SWIG_fail;
43538 {
43539 arg2 = &temp2;
43540 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43541 }
43542 {
43543 PyThreadState* __tstate = wxPyBeginAllowThreads();
43544 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43545
43546 wxPyEndAllowThreads(__tstate);
43547 if (PyErr_Occurred()) SWIG_fail;
43548 }
43549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43550 return resultobj;
43551 fail:
43552 return NULL;
43553 }
43554
43555
43556 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43557 PyObject *resultobj;
43558 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43559 wxPoint *arg2 = 0 ;
43560 wxGBSizerItem *result;
43561 wxPoint temp2 ;
43562 PyObject * obj0 = 0 ;
43563 PyObject * obj1 = 0 ;
43564 char *kwnames[] = {
43565 (char *) "self",(char *) "pt", NULL
43566 };
43567
43568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43570 if (SWIG_arg_fail(1)) SWIG_fail;
43571 {
43572 arg2 = &temp2;
43573 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43574 }
43575 {
43576 PyThreadState* __tstate = wxPyBeginAllowThreads();
43577 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43578
43579 wxPyEndAllowThreads(__tstate);
43580 if (PyErr_Occurred()) SWIG_fail;
43581 }
43582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43583 return resultobj;
43584 fail:
43585 return NULL;
43586 }
43587
43588
43589 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43590 PyObject *resultobj;
43591 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43592 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43593 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43594 bool result;
43595 PyObject * obj0 = 0 ;
43596 PyObject * obj1 = 0 ;
43597 PyObject * obj2 = 0 ;
43598 char *kwnames[] = {
43599 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43600 };
43601
43602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43604 if (SWIG_arg_fail(1)) SWIG_fail;
43605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43606 if (SWIG_arg_fail(2)) SWIG_fail;
43607 if (obj2) {
43608 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43609 if (SWIG_arg_fail(3)) SWIG_fail;
43610 }
43611 {
43612 PyThreadState* __tstate = wxPyBeginAllowThreads();
43613 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43614
43615 wxPyEndAllowThreads(__tstate);
43616 if (PyErr_Occurred()) SWIG_fail;
43617 }
43618 {
43619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43620 }
43621 return resultobj;
43622 fail:
43623 return NULL;
43624 }
43625
43626
43627 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43628 PyObject *resultobj;
43629 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43630 wxGBPosition *arg2 = 0 ;
43631 wxGBSpan *arg3 = 0 ;
43632 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43633 bool result;
43634 wxGBPosition temp2 ;
43635 wxGBSpan temp3 ;
43636 PyObject * obj0 = 0 ;
43637 PyObject * obj1 = 0 ;
43638 PyObject * obj2 = 0 ;
43639 PyObject * obj3 = 0 ;
43640 char *kwnames[] = {
43641 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43642 };
43643
43644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43646 if (SWIG_arg_fail(1)) SWIG_fail;
43647 {
43648 arg2 = &temp2;
43649 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43650 }
43651 {
43652 arg3 = &temp3;
43653 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43654 }
43655 if (obj3) {
43656 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43657 if (SWIG_arg_fail(4)) SWIG_fail;
43658 }
43659 {
43660 PyThreadState* __tstate = wxPyBeginAllowThreads();
43661 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43662
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43668 }
43669 return resultobj;
43670 fail:
43671 return NULL;
43672 }
43673
43674
43675 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43676 PyObject *obj;
43677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43678 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43679 Py_INCREF(obj);
43680 return Py_BuildValue((char *)"");
43681 }
43682 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43683 PyObject *resultobj;
43684 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43685 wxRelationship arg2 ;
43686 wxWindow *arg3 = (wxWindow *) 0 ;
43687 wxEdge arg4 ;
43688 int arg5 = (int) 0 ;
43689 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43690 PyObject * obj0 = 0 ;
43691 PyObject * obj1 = 0 ;
43692 PyObject * obj2 = 0 ;
43693 PyObject * obj3 = 0 ;
43694 PyObject * obj4 = 0 ;
43695 PyObject * obj5 = 0 ;
43696 char *kwnames[] = {
43697 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43698 };
43699
43700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43702 if (SWIG_arg_fail(1)) SWIG_fail;
43703 {
43704 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43705 if (SWIG_arg_fail(2)) SWIG_fail;
43706 }
43707 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43708 if (SWIG_arg_fail(3)) SWIG_fail;
43709 {
43710 arg4 = (wxEdge)(SWIG_As_int(obj3));
43711 if (SWIG_arg_fail(4)) SWIG_fail;
43712 }
43713 if (obj4) {
43714 {
43715 arg5 = (int)(SWIG_As_int(obj4));
43716 if (SWIG_arg_fail(5)) SWIG_fail;
43717 }
43718 }
43719 if (obj5) {
43720 {
43721 arg6 = (int)(SWIG_As_int(obj5));
43722 if (SWIG_arg_fail(6)) SWIG_fail;
43723 }
43724 }
43725 {
43726 PyThreadState* __tstate = wxPyBeginAllowThreads();
43727 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43728
43729 wxPyEndAllowThreads(__tstate);
43730 if (PyErr_Occurred()) SWIG_fail;
43731 }
43732 Py_INCREF(Py_None); resultobj = Py_None;
43733 return resultobj;
43734 fail:
43735 return NULL;
43736 }
43737
43738
43739 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43740 PyObject *resultobj;
43741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43742 wxWindow *arg2 = (wxWindow *) 0 ;
43743 int arg3 = (int) 0 ;
43744 PyObject * obj0 = 0 ;
43745 PyObject * obj1 = 0 ;
43746 PyObject * obj2 = 0 ;
43747 char *kwnames[] = {
43748 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43749 };
43750
43751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43753 if (SWIG_arg_fail(1)) SWIG_fail;
43754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43755 if (SWIG_arg_fail(2)) SWIG_fail;
43756 if (obj2) {
43757 {
43758 arg3 = (int)(SWIG_As_int(obj2));
43759 if (SWIG_arg_fail(3)) SWIG_fail;
43760 }
43761 }
43762 {
43763 PyThreadState* __tstate = wxPyBeginAllowThreads();
43764 (arg1)->LeftOf(arg2,arg3);
43765
43766 wxPyEndAllowThreads(__tstate);
43767 if (PyErr_Occurred()) SWIG_fail;
43768 }
43769 Py_INCREF(Py_None); resultobj = Py_None;
43770 return resultobj;
43771 fail:
43772 return NULL;
43773 }
43774
43775
43776 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43777 PyObject *resultobj;
43778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43779 wxWindow *arg2 = (wxWindow *) 0 ;
43780 int arg3 = (int) 0 ;
43781 PyObject * obj0 = 0 ;
43782 PyObject * obj1 = 0 ;
43783 PyObject * obj2 = 0 ;
43784 char *kwnames[] = {
43785 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43786 };
43787
43788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43790 if (SWIG_arg_fail(1)) SWIG_fail;
43791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43792 if (SWIG_arg_fail(2)) SWIG_fail;
43793 if (obj2) {
43794 {
43795 arg3 = (int)(SWIG_As_int(obj2));
43796 if (SWIG_arg_fail(3)) SWIG_fail;
43797 }
43798 }
43799 {
43800 PyThreadState* __tstate = wxPyBeginAllowThreads();
43801 (arg1)->RightOf(arg2,arg3);
43802
43803 wxPyEndAllowThreads(__tstate);
43804 if (PyErr_Occurred()) SWIG_fail;
43805 }
43806 Py_INCREF(Py_None); resultobj = Py_None;
43807 return resultobj;
43808 fail:
43809 return NULL;
43810 }
43811
43812
43813 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43814 PyObject *resultobj;
43815 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43816 wxWindow *arg2 = (wxWindow *) 0 ;
43817 int arg3 = (int) 0 ;
43818 PyObject * obj0 = 0 ;
43819 PyObject * obj1 = 0 ;
43820 PyObject * obj2 = 0 ;
43821 char *kwnames[] = {
43822 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43823 };
43824
43825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43827 if (SWIG_arg_fail(1)) SWIG_fail;
43828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43829 if (SWIG_arg_fail(2)) SWIG_fail;
43830 if (obj2) {
43831 {
43832 arg3 = (int)(SWIG_As_int(obj2));
43833 if (SWIG_arg_fail(3)) SWIG_fail;
43834 }
43835 }
43836 {
43837 PyThreadState* __tstate = wxPyBeginAllowThreads();
43838 (arg1)->Above(arg2,arg3);
43839
43840 wxPyEndAllowThreads(__tstate);
43841 if (PyErr_Occurred()) SWIG_fail;
43842 }
43843 Py_INCREF(Py_None); resultobj = Py_None;
43844 return resultobj;
43845 fail:
43846 return NULL;
43847 }
43848
43849
43850 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43851 PyObject *resultobj;
43852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43853 wxWindow *arg2 = (wxWindow *) 0 ;
43854 int arg3 = (int) 0 ;
43855 PyObject * obj0 = 0 ;
43856 PyObject * obj1 = 0 ;
43857 PyObject * obj2 = 0 ;
43858 char *kwnames[] = {
43859 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43860 };
43861
43862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43864 if (SWIG_arg_fail(1)) SWIG_fail;
43865 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43866 if (SWIG_arg_fail(2)) SWIG_fail;
43867 if (obj2) {
43868 {
43869 arg3 = (int)(SWIG_As_int(obj2));
43870 if (SWIG_arg_fail(3)) SWIG_fail;
43871 }
43872 }
43873 {
43874 PyThreadState* __tstate = wxPyBeginAllowThreads();
43875 (arg1)->Below(arg2,arg3);
43876
43877 wxPyEndAllowThreads(__tstate);
43878 if (PyErr_Occurred()) SWIG_fail;
43879 }
43880 Py_INCREF(Py_None); resultobj = Py_None;
43881 return resultobj;
43882 fail:
43883 return NULL;
43884 }
43885
43886
43887 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43888 PyObject *resultobj;
43889 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43890 wxWindow *arg2 = (wxWindow *) 0 ;
43891 wxEdge arg3 ;
43892 int arg4 = (int) 0 ;
43893 PyObject * obj0 = 0 ;
43894 PyObject * obj1 = 0 ;
43895 PyObject * obj2 = 0 ;
43896 PyObject * obj3 = 0 ;
43897 char *kwnames[] = {
43898 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43899 };
43900
43901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43903 if (SWIG_arg_fail(1)) SWIG_fail;
43904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43905 if (SWIG_arg_fail(2)) SWIG_fail;
43906 {
43907 arg3 = (wxEdge)(SWIG_As_int(obj2));
43908 if (SWIG_arg_fail(3)) SWIG_fail;
43909 }
43910 if (obj3) {
43911 {
43912 arg4 = (int)(SWIG_As_int(obj3));
43913 if (SWIG_arg_fail(4)) SWIG_fail;
43914 }
43915 }
43916 {
43917 PyThreadState* __tstate = wxPyBeginAllowThreads();
43918 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43919
43920 wxPyEndAllowThreads(__tstate);
43921 if (PyErr_Occurred()) SWIG_fail;
43922 }
43923 Py_INCREF(Py_None); resultobj = Py_None;
43924 return resultobj;
43925 fail:
43926 return NULL;
43927 }
43928
43929
43930 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43931 PyObject *resultobj;
43932 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43933 wxWindow *arg2 = (wxWindow *) 0 ;
43934 wxEdge arg3 ;
43935 int arg4 ;
43936 PyObject * obj0 = 0 ;
43937 PyObject * obj1 = 0 ;
43938 PyObject * obj2 = 0 ;
43939 PyObject * obj3 = 0 ;
43940 char *kwnames[] = {
43941 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43942 };
43943
43944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43946 if (SWIG_arg_fail(1)) SWIG_fail;
43947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43948 if (SWIG_arg_fail(2)) SWIG_fail;
43949 {
43950 arg3 = (wxEdge)(SWIG_As_int(obj2));
43951 if (SWIG_arg_fail(3)) SWIG_fail;
43952 }
43953 {
43954 arg4 = (int)(SWIG_As_int(obj3));
43955 if (SWIG_arg_fail(4)) SWIG_fail;
43956 }
43957 {
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43960
43961 wxPyEndAllowThreads(__tstate);
43962 if (PyErr_Occurred()) SWIG_fail;
43963 }
43964 Py_INCREF(Py_None); resultobj = Py_None;
43965 return resultobj;
43966 fail:
43967 return NULL;
43968 }
43969
43970
43971 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43972 PyObject *resultobj;
43973 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43974 int arg2 ;
43975 PyObject * obj0 = 0 ;
43976 PyObject * obj1 = 0 ;
43977 char *kwnames[] = {
43978 (char *) "self",(char *) "val", NULL
43979 };
43980
43981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43983 if (SWIG_arg_fail(1)) SWIG_fail;
43984 {
43985 arg2 = (int)(SWIG_As_int(obj1));
43986 if (SWIG_arg_fail(2)) SWIG_fail;
43987 }
43988 {
43989 PyThreadState* __tstate = wxPyBeginAllowThreads();
43990 (arg1)->Absolute(arg2);
43991
43992 wxPyEndAllowThreads(__tstate);
43993 if (PyErr_Occurred()) SWIG_fail;
43994 }
43995 Py_INCREF(Py_None); resultobj = Py_None;
43996 return resultobj;
43997 fail:
43998 return NULL;
43999 }
44000
44001
44002 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44003 PyObject *resultobj;
44004 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44005 PyObject * obj0 = 0 ;
44006 char *kwnames[] = {
44007 (char *) "self", NULL
44008 };
44009
44010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44012 if (SWIG_arg_fail(1)) SWIG_fail;
44013 {
44014 PyThreadState* __tstate = wxPyBeginAllowThreads();
44015 (arg1)->Unconstrained();
44016
44017 wxPyEndAllowThreads(__tstate);
44018 if (PyErr_Occurred()) SWIG_fail;
44019 }
44020 Py_INCREF(Py_None); resultobj = Py_None;
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44028 PyObject *resultobj;
44029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44030 PyObject * obj0 = 0 ;
44031 char *kwnames[] = {
44032 (char *) "self", NULL
44033 };
44034
44035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44037 if (SWIG_arg_fail(1)) SWIG_fail;
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 (arg1)->AsIs();
44041
44042 wxPyEndAllowThreads(__tstate);
44043 if (PyErr_Occurred()) SWIG_fail;
44044 }
44045 Py_INCREF(Py_None); resultobj = Py_None;
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44053 PyObject *resultobj;
44054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44055 wxWindow *result;
44056 PyObject * obj0 = 0 ;
44057 char *kwnames[] = {
44058 (char *) "self", NULL
44059 };
44060
44061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44063 if (SWIG_arg_fail(1)) SWIG_fail;
44064 {
44065 PyThreadState* __tstate = wxPyBeginAllowThreads();
44066 result = (wxWindow *)(arg1)->GetOtherWindow();
44067
44068 wxPyEndAllowThreads(__tstate);
44069 if (PyErr_Occurred()) SWIG_fail;
44070 }
44071 {
44072 resultobj = wxPyMake_wxObject(result, 0);
44073 }
44074 return resultobj;
44075 fail:
44076 return NULL;
44077 }
44078
44079
44080 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44081 PyObject *resultobj;
44082 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44083 wxEdge result;
44084 PyObject * obj0 = 0 ;
44085 char *kwnames[] = {
44086 (char *) "self", NULL
44087 };
44088
44089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44091 if (SWIG_arg_fail(1)) SWIG_fail;
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44095
44096 wxPyEndAllowThreads(__tstate);
44097 if (PyErr_Occurred()) SWIG_fail;
44098 }
44099 resultobj = SWIG_From_int((result));
44100 return resultobj;
44101 fail:
44102 return NULL;
44103 }
44104
44105
44106 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44107 PyObject *resultobj;
44108 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44109 wxEdge arg2 ;
44110 PyObject * obj0 = 0 ;
44111 PyObject * obj1 = 0 ;
44112 char *kwnames[] = {
44113 (char *) "self",(char *) "which", NULL
44114 };
44115
44116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44118 if (SWIG_arg_fail(1)) SWIG_fail;
44119 {
44120 arg2 = (wxEdge)(SWIG_As_int(obj1));
44121 if (SWIG_arg_fail(2)) SWIG_fail;
44122 }
44123 {
44124 PyThreadState* __tstate = wxPyBeginAllowThreads();
44125 (arg1)->SetEdge((wxEdge )arg2);
44126
44127 wxPyEndAllowThreads(__tstate);
44128 if (PyErr_Occurred()) SWIG_fail;
44129 }
44130 Py_INCREF(Py_None); resultobj = Py_None;
44131 return resultobj;
44132 fail:
44133 return NULL;
44134 }
44135
44136
44137 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44138 PyObject *resultobj;
44139 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44140 int arg2 ;
44141 PyObject * obj0 = 0 ;
44142 PyObject * obj1 = 0 ;
44143 char *kwnames[] = {
44144 (char *) "self",(char *) "v", NULL
44145 };
44146
44147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44149 if (SWIG_arg_fail(1)) SWIG_fail;
44150 {
44151 arg2 = (int)(SWIG_As_int(obj1));
44152 if (SWIG_arg_fail(2)) SWIG_fail;
44153 }
44154 {
44155 PyThreadState* __tstate = wxPyBeginAllowThreads();
44156 (arg1)->SetValue(arg2);
44157
44158 wxPyEndAllowThreads(__tstate);
44159 if (PyErr_Occurred()) SWIG_fail;
44160 }
44161 Py_INCREF(Py_None); resultobj = Py_None;
44162 return resultobj;
44163 fail:
44164 return NULL;
44165 }
44166
44167
44168 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44169 PyObject *resultobj;
44170 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44171 int result;
44172 PyObject * obj0 = 0 ;
44173 char *kwnames[] = {
44174 (char *) "self", NULL
44175 };
44176
44177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44179 if (SWIG_arg_fail(1)) SWIG_fail;
44180 {
44181 PyThreadState* __tstate = wxPyBeginAllowThreads();
44182 result = (int)(arg1)->GetMargin();
44183
44184 wxPyEndAllowThreads(__tstate);
44185 if (PyErr_Occurred()) SWIG_fail;
44186 }
44187 {
44188 resultobj = SWIG_From_int((int)(result));
44189 }
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj;
44198 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44199 int arg2 ;
44200 PyObject * obj0 = 0 ;
44201 PyObject * obj1 = 0 ;
44202 char *kwnames[] = {
44203 (char *) "self",(char *) "m", NULL
44204 };
44205
44206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44208 if (SWIG_arg_fail(1)) SWIG_fail;
44209 {
44210 arg2 = (int)(SWIG_As_int(obj1));
44211 if (SWIG_arg_fail(2)) SWIG_fail;
44212 }
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 (arg1)->SetMargin(arg2);
44216
44217 wxPyEndAllowThreads(__tstate);
44218 if (PyErr_Occurred()) SWIG_fail;
44219 }
44220 Py_INCREF(Py_None); resultobj = Py_None;
44221 return resultobj;
44222 fail:
44223 return NULL;
44224 }
44225
44226
44227 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj;
44229 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44230 int result;
44231 PyObject * obj0 = 0 ;
44232 char *kwnames[] = {
44233 (char *) "self", NULL
44234 };
44235
44236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44238 if (SWIG_arg_fail(1)) SWIG_fail;
44239 {
44240 PyThreadState* __tstate = wxPyBeginAllowThreads();
44241 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44242
44243 wxPyEndAllowThreads(__tstate);
44244 if (PyErr_Occurred()) SWIG_fail;
44245 }
44246 {
44247 resultobj = SWIG_From_int((int)(result));
44248 }
44249 return resultobj;
44250 fail:
44251 return NULL;
44252 }
44253
44254
44255 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44256 PyObject *resultobj;
44257 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44258 int result;
44259 PyObject * obj0 = 0 ;
44260 char *kwnames[] = {
44261 (char *) "self", NULL
44262 };
44263
44264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44266 if (SWIG_arg_fail(1)) SWIG_fail;
44267 {
44268 PyThreadState* __tstate = wxPyBeginAllowThreads();
44269 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44270
44271 wxPyEndAllowThreads(__tstate);
44272 if (PyErr_Occurred()) SWIG_fail;
44273 }
44274 {
44275 resultobj = SWIG_From_int((int)(result));
44276 }
44277 return resultobj;
44278 fail:
44279 return NULL;
44280 }
44281
44282
44283 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44284 PyObject *resultobj;
44285 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44286 int result;
44287 PyObject * obj0 = 0 ;
44288 char *kwnames[] = {
44289 (char *) "self", NULL
44290 };
44291
44292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44294 if (SWIG_arg_fail(1)) SWIG_fail;
44295 {
44296 PyThreadState* __tstate = wxPyBeginAllowThreads();
44297 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44298
44299 wxPyEndAllowThreads(__tstate);
44300 if (PyErr_Occurred()) SWIG_fail;
44301 }
44302 {
44303 resultobj = SWIG_From_int((int)(result));
44304 }
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44312 PyObject *resultobj;
44313 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44314 bool result;
44315 PyObject * obj0 = 0 ;
44316 char *kwnames[] = {
44317 (char *) "self", NULL
44318 };
44319
44320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44322 if (SWIG_arg_fail(1)) SWIG_fail;
44323 {
44324 PyThreadState* __tstate = wxPyBeginAllowThreads();
44325 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44326
44327 wxPyEndAllowThreads(__tstate);
44328 if (PyErr_Occurred()) SWIG_fail;
44329 }
44330 {
44331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44332 }
44333 return resultobj;
44334 fail:
44335 return NULL;
44336 }
44337
44338
44339 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44340 PyObject *resultobj;
44341 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44342 bool arg2 ;
44343 PyObject * obj0 = 0 ;
44344 PyObject * obj1 = 0 ;
44345 char *kwnames[] = {
44346 (char *) "self",(char *) "d", NULL
44347 };
44348
44349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44351 if (SWIG_arg_fail(1)) SWIG_fail;
44352 {
44353 arg2 = (bool)(SWIG_As_bool(obj1));
44354 if (SWIG_arg_fail(2)) SWIG_fail;
44355 }
44356 {
44357 PyThreadState* __tstate = wxPyBeginAllowThreads();
44358 (arg1)->SetDone(arg2);
44359
44360 wxPyEndAllowThreads(__tstate);
44361 if (PyErr_Occurred()) SWIG_fail;
44362 }
44363 Py_INCREF(Py_None); resultobj = Py_None;
44364 return resultobj;
44365 fail:
44366 return NULL;
44367 }
44368
44369
44370 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44371 PyObject *resultobj;
44372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44373 wxRelationship result;
44374 PyObject * obj0 = 0 ;
44375 char *kwnames[] = {
44376 (char *) "self", NULL
44377 };
44378
44379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44381 if (SWIG_arg_fail(1)) SWIG_fail;
44382 {
44383 PyThreadState* __tstate = wxPyBeginAllowThreads();
44384 result = (wxRelationship)(arg1)->GetRelationship();
44385
44386 wxPyEndAllowThreads(__tstate);
44387 if (PyErr_Occurred()) SWIG_fail;
44388 }
44389 resultobj = SWIG_From_int((result));
44390 return resultobj;
44391 fail:
44392 return NULL;
44393 }
44394
44395
44396 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44397 PyObject *resultobj;
44398 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44399 wxRelationship arg2 ;
44400 PyObject * obj0 = 0 ;
44401 PyObject * obj1 = 0 ;
44402 char *kwnames[] = {
44403 (char *) "self",(char *) "r", NULL
44404 };
44405
44406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44408 if (SWIG_arg_fail(1)) SWIG_fail;
44409 {
44410 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44411 if (SWIG_arg_fail(2)) SWIG_fail;
44412 }
44413 {
44414 PyThreadState* __tstate = wxPyBeginAllowThreads();
44415 (arg1)->SetRelationship((wxRelationship )arg2);
44416
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 Py_INCREF(Py_None); resultobj = Py_None;
44421 return resultobj;
44422 fail:
44423 return NULL;
44424 }
44425
44426
44427 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44428 PyObject *resultobj;
44429 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44430 wxWindow *arg2 = (wxWindow *) 0 ;
44431 bool result;
44432 PyObject * obj0 = 0 ;
44433 PyObject * obj1 = 0 ;
44434 char *kwnames[] = {
44435 (char *) "self",(char *) "otherW", NULL
44436 };
44437
44438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44440 if (SWIG_arg_fail(1)) SWIG_fail;
44441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44442 if (SWIG_arg_fail(2)) SWIG_fail;
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 result = (bool)(arg1)->ResetIfWin(arg2);
44446
44447 wxPyEndAllowThreads(__tstate);
44448 if (PyErr_Occurred()) SWIG_fail;
44449 }
44450 {
44451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44452 }
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44460 PyObject *resultobj;
44461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44462 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44463 wxWindow *arg3 = (wxWindow *) 0 ;
44464 bool result;
44465 PyObject * obj0 = 0 ;
44466 PyObject * obj1 = 0 ;
44467 PyObject * obj2 = 0 ;
44468 char *kwnames[] = {
44469 (char *) "self",(char *) "constraints",(char *) "win", NULL
44470 };
44471
44472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44474 if (SWIG_arg_fail(1)) SWIG_fail;
44475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44476 if (SWIG_arg_fail(2)) SWIG_fail;
44477 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44478 if (SWIG_arg_fail(3)) SWIG_fail;
44479 {
44480 PyThreadState* __tstate = wxPyBeginAllowThreads();
44481 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44482
44483 wxPyEndAllowThreads(__tstate);
44484 if (PyErr_Occurred()) SWIG_fail;
44485 }
44486 {
44487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44488 }
44489 return resultobj;
44490 fail:
44491 return NULL;
44492 }
44493
44494
44495 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44496 PyObject *resultobj;
44497 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44498 wxEdge arg2 ;
44499 wxWindow *arg3 = (wxWindow *) 0 ;
44500 wxWindow *arg4 = (wxWindow *) 0 ;
44501 int result;
44502 PyObject * obj0 = 0 ;
44503 PyObject * obj1 = 0 ;
44504 PyObject * obj2 = 0 ;
44505 PyObject * obj3 = 0 ;
44506 char *kwnames[] = {
44507 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44508 };
44509
44510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44512 if (SWIG_arg_fail(1)) SWIG_fail;
44513 {
44514 arg2 = (wxEdge)(SWIG_As_int(obj1));
44515 if (SWIG_arg_fail(2)) SWIG_fail;
44516 }
44517 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44518 if (SWIG_arg_fail(3)) SWIG_fail;
44519 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44520 if (SWIG_arg_fail(4)) SWIG_fail;
44521 {
44522 PyThreadState* __tstate = wxPyBeginAllowThreads();
44523 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44524
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 {
44529 resultobj = SWIG_From_int((int)(result));
44530 }
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44538 PyObject *obj;
44539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44540 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44541 Py_INCREF(obj);
44542 return Py_BuildValue((char *)"");
44543 }
44544 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44545 PyObject *resultobj;
44546 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44547 wxIndividualLayoutConstraint *result;
44548 PyObject * obj0 = 0 ;
44549 char *kwnames[] = {
44550 (char *) "self", NULL
44551 };
44552
44553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44555 if (SWIG_arg_fail(1)) SWIG_fail;
44556 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44557
44558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44559 return resultobj;
44560 fail:
44561 return NULL;
44562 }
44563
44564
44565 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44566 PyObject *resultobj;
44567 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44568 wxIndividualLayoutConstraint *result;
44569 PyObject * obj0 = 0 ;
44570 char *kwnames[] = {
44571 (char *) "self", NULL
44572 };
44573
44574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44576 if (SWIG_arg_fail(1)) SWIG_fail;
44577 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44578
44579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44580 return resultobj;
44581 fail:
44582 return NULL;
44583 }
44584
44585
44586 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44587 PyObject *resultobj;
44588 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44589 wxIndividualLayoutConstraint *result;
44590 PyObject * obj0 = 0 ;
44591 char *kwnames[] = {
44592 (char *) "self", NULL
44593 };
44594
44595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44597 if (SWIG_arg_fail(1)) SWIG_fail;
44598 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44599
44600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44601 return resultobj;
44602 fail:
44603 return NULL;
44604 }
44605
44606
44607 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44608 PyObject *resultobj;
44609 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44610 wxIndividualLayoutConstraint *result;
44611 PyObject * obj0 = 0 ;
44612 char *kwnames[] = {
44613 (char *) "self", NULL
44614 };
44615
44616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44618 if (SWIG_arg_fail(1)) SWIG_fail;
44619 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44620
44621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44622 return resultobj;
44623 fail:
44624 return NULL;
44625 }
44626
44627
44628 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44629 PyObject *resultobj;
44630 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44631 wxIndividualLayoutConstraint *result;
44632 PyObject * obj0 = 0 ;
44633 char *kwnames[] = {
44634 (char *) "self", NULL
44635 };
44636
44637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44639 if (SWIG_arg_fail(1)) SWIG_fail;
44640 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44641
44642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44643 return resultobj;
44644 fail:
44645 return NULL;
44646 }
44647
44648
44649 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44650 PyObject *resultobj;
44651 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44652 wxIndividualLayoutConstraint *result;
44653 PyObject * obj0 = 0 ;
44654 char *kwnames[] = {
44655 (char *) "self", NULL
44656 };
44657
44658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44660 if (SWIG_arg_fail(1)) SWIG_fail;
44661 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44662
44663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44664 return resultobj;
44665 fail:
44666 return NULL;
44667 }
44668
44669
44670 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44671 PyObject *resultobj;
44672 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44673 wxIndividualLayoutConstraint *result;
44674 PyObject * obj0 = 0 ;
44675 char *kwnames[] = {
44676 (char *) "self", NULL
44677 };
44678
44679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44681 if (SWIG_arg_fail(1)) SWIG_fail;
44682 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44683
44684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44685 return resultobj;
44686 fail:
44687 return NULL;
44688 }
44689
44690
44691 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44692 PyObject *resultobj;
44693 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44694 wxIndividualLayoutConstraint *result;
44695 PyObject * obj0 = 0 ;
44696 char *kwnames[] = {
44697 (char *) "self", NULL
44698 };
44699
44700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44702 if (SWIG_arg_fail(1)) SWIG_fail;
44703 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44704
44705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44706 return resultobj;
44707 fail:
44708 return NULL;
44709 }
44710
44711
44712 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44713 PyObject *resultobj;
44714 wxLayoutConstraints *result;
44715 char *kwnames[] = {
44716 NULL
44717 };
44718
44719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44720 {
44721 PyThreadState* __tstate = wxPyBeginAllowThreads();
44722 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44723
44724 wxPyEndAllowThreads(__tstate);
44725 if (PyErr_Occurred()) SWIG_fail;
44726 }
44727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44728 return resultobj;
44729 fail:
44730 return NULL;
44731 }
44732
44733
44734 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44735 PyObject *resultobj;
44736 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44737 wxWindow *arg2 = (wxWindow *) 0 ;
44738 int *arg3 = (int *) 0 ;
44739 bool result;
44740 int temp3 ;
44741 int res3 = 0 ;
44742 PyObject * obj0 = 0 ;
44743 PyObject * obj1 = 0 ;
44744 char *kwnames[] = {
44745 (char *) "self",(char *) "win", NULL
44746 };
44747
44748 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44751 if (SWIG_arg_fail(1)) SWIG_fail;
44752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44753 if (SWIG_arg_fail(2)) SWIG_fail;
44754 {
44755 PyThreadState* __tstate = wxPyBeginAllowThreads();
44756 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44757
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 {
44762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44763 }
44764 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44765 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44766 return resultobj;
44767 fail:
44768 return NULL;
44769 }
44770
44771
44772 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44773 PyObject *resultobj;
44774 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44775 bool result;
44776 PyObject * obj0 = 0 ;
44777 char *kwnames[] = {
44778 (char *) "self", NULL
44779 };
44780
44781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44783 if (SWIG_arg_fail(1)) SWIG_fail;
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44787
44788 wxPyEndAllowThreads(__tstate);
44789 if (PyErr_Occurred()) SWIG_fail;
44790 }
44791 {
44792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44793 }
44794 return resultobj;
44795 fail:
44796 return NULL;
44797 }
44798
44799
44800 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44801 PyObject *obj;
44802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44803 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44804 Py_INCREF(obj);
44805 return Py_BuildValue((char *)"");
44806 }
44807 static PyMethodDef SwigMethods[] = {
44808 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44809 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44810 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44813 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44834 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44847 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44862 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44915 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44943 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44962 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44964 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44972 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44973 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44985 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44997 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45001 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45007 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45017 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45027 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45031 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45106 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45108 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45110 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45112 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45114 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45116 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45118 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45120 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45122 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45124 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45126 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45128 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45130 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45144 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45162 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45165 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45168 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45180 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45185 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45191 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45197 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45260 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45267 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45303 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45313 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45319 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45321 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45323 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45326 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45330 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45333 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45336 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45338 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45343 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45351 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45355 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45358 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45360 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45364 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45381 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45383 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45386 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45388 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45392 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45396 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45407 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45410 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45413 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45417 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45424 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45429 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45434 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45438 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45483 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45503 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45510 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45514 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45524 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45696 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45736 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45750 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45753 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45808 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45835 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45879 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45887 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45906 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45907 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45944 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45974 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45977 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45981 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45984 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45994 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46006 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46018 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46028 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46038 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46052 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46059 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46060 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46061 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46062 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46063 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46068 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46095 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46107 { NULL, NULL, 0, NULL }
46108 };
46109
46110
46111 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46112
46113 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46114 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46115 }
46116 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46117 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46118 }
46119 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46120 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46121 }
46122 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46123 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46124 }
46125 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46126 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46127 }
46128 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46129 return (void *)((wxSizer *) ((wxGridSizer *) x));
46130 }
46131 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46132 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46133 }
46134 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46135 return (void *)((wxSizer *) ((wxPySizer *) x));
46136 }
46137 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46138 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46139 }
46140 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46141 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46142 }
46143 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46144 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46145 }
46146 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46147 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46148 }
46149 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46150 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46151 }
46152 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46153 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46154 }
46155 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46156 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46157 }
46158 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46159 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46160 }
46161 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46162 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46163 }
46164 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46165 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46166 }
46167 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46168 return (void *)((wxEvent *) ((wxPyEvent *) x));
46169 }
46170 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46171 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46172 }
46173 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46174 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46175 }
46176 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46177 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46178 }
46179 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46180 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46181 }
46182 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46183 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46184 }
46185 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46186 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46187 }
46188 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46189 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46190 }
46191 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46192 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46193 }
46194 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46195 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46196 }
46197 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46198 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46199 }
46200 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46201 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46202 }
46203 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46204 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46205 }
46206 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46207 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46208 }
46209 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46210 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46211 }
46212 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46213 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46214 }
46215 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46216 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46217 }
46218 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46219 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46220 }
46221 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46222 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46223 }
46224 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46225 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46226 }
46227 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46228 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46229 }
46230 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46231 return (void *)((wxEvent *) ((wxShowEvent *) x));
46232 }
46233 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46234 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46235 }
46236 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46238 }
46239 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46240 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46241 }
46242 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46243 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46244 }
46245 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46246 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46247 }
46248 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46249 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46250 }
46251 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46252 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46253 }
46254 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46255 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46256 }
46257 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46258 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46259 }
46260 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46261 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46262 }
46263 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46264 return (void *)((wxControl *) ((wxControlWithItems *) x));
46265 }
46266 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46267 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46268 }
46269 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46270 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46271 }
46272 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46273 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46274 }
46275 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46276 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46277 }
46278 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46279 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46280 }
46281 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46282 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46283 }
46284 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46285 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46286 }
46287 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46288 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46289 }
46290 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46291 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46292 }
46293 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46294 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46295 }
46296 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46297 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46298 }
46299 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46300 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46301 }
46302 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46303 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46304 }
46305 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46306 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46307 }
46308 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46309 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46310 }
46311 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46312 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46313 }
46314 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46315 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46316 }
46317 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46318 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46319 }
46320 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46321 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46322 }
46323 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46324 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46325 }
46326 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46327 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46328 }
46329 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46330 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46331 }
46332 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46333 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46334 }
46335 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46336 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46337 }
46338 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46339 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46340 }
46341 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46342 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46343 }
46344 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46345 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46346 }
46347 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46348 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46349 }
46350 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46351 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46352 }
46353 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46354 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46355 }
46356 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46357 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46358 }
46359 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46360 return (void *)((wxObject *) ((wxSizerItem *) x));
46361 }
46362 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46363 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46364 }
46365 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46366 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46367 }
46368 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46369 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46370 }
46371 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46372 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46373 }
46374 static void *_p_wxSizerTo_p_wxObject(void *x) {
46375 return (void *)((wxObject *) ((wxSizer *) x));
46376 }
46377 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46378 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46379 }
46380 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46381 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46382 }
46383 static void *_p_wxEventTo_p_wxObject(void *x) {
46384 return (void *)((wxObject *) ((wxEvent *) x));
46385 }
46386 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46387 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46388 }
46389 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46390 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46391 }
46392 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46393 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46394 }
46395 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46396 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46397 }
46398 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46399 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46400 }
46401 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46402 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46403 }
46404 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46405 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46406 }
46407 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46408 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46409 }
46410 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46411 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46412 }
46413 static void *_p_wxControlTo_p_wxObject(void *x) {
46414 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46415 }
46416 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46417 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46418 }
46419 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46420 return (void *)((wxObject *) ((wxFSFile *) x));
46421 }
46422 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46423 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46424 }
46425 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46426 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46427 }
46428 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46429 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46430 }
46431 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46432 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46433 }
46434 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46435 return (void *)((wxObject *) ((wxMenuItem *) x));
46436 }
46437 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46439 }
46440 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46441 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46442 }
46443 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46445 }
46446 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46447 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46448 }
46449 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46450 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46451 }
46452 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46453 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46454 }
46455 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46456 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46457 }
46458 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46459 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46460 }
46461 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46462 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46463 }
46464 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46465 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46466 }
46467 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46468 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46469 }
46470 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46471 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46472 }
46473 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46474 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46475 }
46476 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46477 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46478 }
46479 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46480 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46481 }
46482 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46483 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46484 }
46485 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46486 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46487 }
46488 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46489 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46490 }
46491 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46492 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46493 }
46494 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46495 return (void *)((wxObject *) ((wxImageHandler *) x));
46496 }
46497 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46498 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46499 }
46500 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46501 return (void *)((wxObject *) ((wxEvtHandler *) x));
46502 }
46503 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46504 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46505 }
46506 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46507 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46508 }
46509 static void *_p_wxImageTo_p_wxObject(void *x) {
46510 return (void *)((wxObject *) ((wxImage *) x));
46511 }
46512 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46513 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46514 }
46515 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46517 }
46518 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46519 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46520 }
46521 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46522 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46523 }
46524 static void *_p_wxWindowTo_p_wxObject(void *x) {
46525 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46526 }
46527 static void *_p_wxMenuTo_p_wxObject(void *x) {
46528 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46529 }
46530 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46531 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46532 }
46533 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46534 return (void *)((wxObject *) ((wxFileSystem *) x));
46535 }
46536 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46537 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46538 }
46539 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46540 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46541 }
46542 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46543 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46544 }
46545 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46546 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46547 }
46548 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46549 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46550 }
46551 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46552 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46553 }
46554 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46555 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46556 }
46557 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46558 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46559 }
46560 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46561 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46562 }
46563 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46564 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46565 }
46566 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46567 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46568 }
46569 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46570 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46571 }
46572 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46573 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46574 }
46575 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46576 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46577 }
46578 static void *_p_wxControlTo_p_wxWindow(void *x) {
46579 return (void *)((wxWindow *) ((wxControl *) x));
46580 }
46581 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46582 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46583 }
46584 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46585 return (void *)((wxWindow *) ((wxMenuBar *) x));
46586 }
46587 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46588 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46589 }
46590 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46591 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46592 }
46593 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46594 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46595 }
46596 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46597 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46598 }
46599 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46600 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46601 }
46602 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46603 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46604 }
46605 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46606 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46607 }
46608 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46609 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46610 }
46611 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46612 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46613 }
46614 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46615 return (void *)((wxValidator *) ((wxPyValidator *) x));
46616 }
46617 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}};
46618 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}};
46619 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}};
46620 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}};
46621 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}};
46622 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}};
46623 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}};
46624 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}};
46625 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}};
46626 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}};
46627 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}};
46628 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}};
46629 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}};
46630 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}};
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 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}};
46645 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}};
46646 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}};
46647 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}};
46648 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}};
46649 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}};
46650 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}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 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}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 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}};
46663 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}};
46664 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}};
46665 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}};
46666 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}};
46667 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}};
46668 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}};
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 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}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 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}};
46684 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}};
46685 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}};
46686 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}};
46687 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}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706 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}};
46707 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}};
46708 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}};
46709 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}};
46710 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}};
46711 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}};
46712 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}};
46713 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}};
46714 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}};
46715 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}};
46716 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}};
46717 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}};
46718 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}};
46719 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}};
46720 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}};
46721 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}};
46722 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}};
46723 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}};
46724 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}};
46725 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}};
46726 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}};
46727 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}};
46728 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46729 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}};
46730 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}};
46731 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}};
46732 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}};
46733 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}};
46734 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}};
46735 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}};
46736 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}};
46737 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}};
46738 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}};
46739 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}};
46740 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}};
46741 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}};
46742 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}};
46743 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}};
46744
46745 static swig_type_info *swig_types_initial[] = {
46746 _swigt__p_wxLayoutConstraints,
46747 _swigt__p_wxRealPoint,
46748 _swigt__p_wxSizerItem,
46749 _swigt__p_wxGBSizerItem,
46750 _swigt__p_wxScrollEvent,
46751 _swigt__p_wxEventLoop,
46752 _swigt__p_wxIndividualLayoutConstraint,
46753 _swigt__p_wxSizer,
46754 _swigt__p_wxBoxSizer,
46755 _swigt__p_wxStaticBoxSizer,
46756 _swigt__p_wxGridBagSizer,
46757 _swigt__p_wxAcceleratorEntry,
46758 _swigt__p_wxUpdateUIEvent,
46759 _swigt__p_wxEvent,
46760 _swigt__p_wxMenu,
46761 _swigt__p_wxGridSizer,
46762 _swigt__p_wxFlexGridSizer,
46763 _swigt__p_wxInitDialogEvent,
46764 _swigt__p_wxItemContainer,
46765 _swigt__p_wxNcPaintEvent,
46766 _swigt__p_wxPaintEvent,
46767 _swigt__p_wxSysColourChangedEvent,
46768 _swigt__p_wxMouseCaptureChangedEvent,
46769 _swigt__p_wxDisplayChangedEvent,
46770 _swigt__p_wxPaletteChangedEvent,
46771 _swigt__p_wxControl,
46772 _swigt__p_wxFont,
46773 _swigt__p_wxMenuBarBase,
46774 _swigt__p_wxSetCursorEvent,
46775 _swigt__p_wxFSFile,
46776 _swigt__p_wxCaret,
46777 _swigt__ptrdiff_t,
46778 _swigt__std__ptrdiff_t,
46779 _swigt__p_wxRegion,
46780 _swigt__p_wxPoint2D,
46781 _swigt__p_int,
46782 _swigt__p_wxSize,
46783 _swigt__p_wxDC,
46784 _swigt__p_wxPySizer,
46785 _swigt__p_wxVisualAttributes,
46786 _swigt__p_wxNotifyEvent,
46787 _swigt__p_wxPyEvent,
46788 _swigt__p_wxPropagationDisabler,
46789 _swigt__p_form_ops_t,
46790 _swigt__p_wxAppTraits,
46791 _swigt__p_wxArrayString,
46792 _swigt__p_wxShowEvent,
46793 _swigt__p_wxToolTip,
46794 _swigt__p_wxMoveEvent,
46795 _swigt__p_wxSizeEvent,
46796 _swigt__p_wxActivateEvent,
46797 _swigt__p_wxIconizeEvent,
46798 _swigt__p_wxMaximizeEvent,
46799 _swigt__p_wxQueryNewPaletteEvent,
46800 _swigt__p_wxWindowCreateEvent,
46801 _swigt__p_wxIdleEvent,
46802 _swigt__p_wxDateEvent,
46803 _swigt__p_wxMenuItem,
46804 _swigt__p_wxStaticBox,
46805 _swigt__p_long,
46806 _swigt__p_wxDuplexMode,
46807 _swigt__p_wxTIFFHandler,
46808 _swigt__p_wxXPMHandler,
46809 _swigt__p_wxPNMHandler,
46810 _swigt__p_wxJPEGHandler,
46811 _swigt__p_wxPCXHandler,
46812 _swigt__p_wxGIFHandler,
46813 _swigt__p_wxPNGHandler,
46814 _swigt__p_wxANIHandler,
46815 _swigt__p_wxMemoryFSHandler,
46816 _swigt__p_wxZipFSHandler,
46817 _swigt__p_wxInternetFSHandler,
46818 _swigt__p_wxPyFileSystemHandler,
46819 _swigt__p_wxEvtHandler,
46820 _swigt__p_wxCURHandler,
46821 _swigt__p_wxICOHandler,
46822 _swigt__p_wxBMPHandler,
46823 _swigt__p_wxImageHandler,
46824 _swigt__p_wxFileSystemHandler,
46825 _swigt__p_wxRect,
46826 _swigt__p_wxButton,
46827 _swigt__p_wxGBSpan,
46828 _swigt__p_wxPropagateOnce,
46829 _swigt__p_wxAcceleratorTable,
46830 _swigt__p_wxStdDialogButtonSizer,
46831 _swigt__p_char,
46832 _swigt__p_wxGBPosition,
46833 _swigt__p_wxImage,
46834 _swigt__p_wxFrame,
46835 _swigt__p_wxScrollWinEvent,
46836 _swigt__p_wxPaperSize,
46837 _swigt__p_wxImageHistogram,
46838 _swigt__p_wxPoint,
46839 _swigt__p_wxCursor,
46840 _swigt__p_wxObject,
46841 _swigt__p_wxInputStream,
46842 _swigt__p_wxOutputStream,
46843 _swigt__p_wxPyInputStream,
46844 _swigt__p_wxDateTime,
46845 _swigt__p_wxKeyEvent,
46846 _swigt__p_wxNavigationKeyEvent,
46847 _swigt__p_wxWindowDestroyEvent,
46848 _swigt__p_unsigned_long,
46849 _swigt__p_wxWindow,
46850 _swigt__p_wxMenuBar,
46851 _swigt__p_wxFileSystem,
46852 _swigt__p_wxBitmap,
46853 _swigt__unsigned_int,
46854 _swigt__p_unsigned_int,
46855 _swigt__p_wxMenuEvent,
46856 _swigt__p_wxContextMenuEvent,
46857 _swigt__p_unsigned_char,
46858 _swigt__p_wxEraseEvent,
46859 _swigt__p_wxMouseEvent,
46860 _swigt__p_wxCloseEvent,
46861 _swigt__p_wxPyApp,
46862 _swigt__p_wxCommandEvent,
46863 _swigt__p_wxPyCommandEvent,
46864 _swigt__p_wxPyDropTarget,
46865 _swigt__p_wxQuantize,
46866 _swigt__p_wxChildFocusEvent,
46867 _swigt__p_wxFocusEvent,
46868 _swigt__p_wxDropFilesEvent,
46869 _swigt__p_wxControlWithItems,
46870 _swigt__p_wxColour,
46871 _swigt__p_wxValidator,
46872 _swigt__p_wxPyValidator,
46873 0
46874 };
46875
46876
46877 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46878
46879 static swig_const_info swig_const_table[] = {
46880 {0, 0, 0, 0.0, 0, 0}};
46881
46882 #ifdef __cplusplus
46883 }
46884 #endif
46885
46886
46887 #ifdef __cplusplus
46888 extern "C" {
46889 #endif
46890
46891 /* Python-specific SWIG API */
46892 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46893 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46894 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46895
46896 /* -----------------------------------------------------------------------------
46897 * global variable support code.
46898 * ----------------------------------------------------------------------------- */
46899
46900 typedef struct swig_globalvar {
46901 char *name; /* Name of global variable */
46902 PyObject *(*get_attr)(); /* Return the current value */
46903 int (*set_attr)(PyObject *); /* Set the value */
46904 struct swig_globalvar *next;
46905 } swig_globalvar;
46906
46907 typedef struct swig_varlinkobject {
46908 PyObject_HEAD
46909 swig_globalvar *vars;
46910 } swig_varlinkobject;
46911
46912 static PyObject *
46913 swig_varlink_repr(swig_varlinkobject *v) {
46914 v = v;
46915 return PyString_FromString("<Swig global variables>");
46916 }
46917
46918 static int
46919 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46920 swig_globalvar *var;
46921 flags = flags;
46922 fprintf(fp,"Swig global variables { ");
46923 for (var = v->vars; var; var=var->next) {
46924 fprintf(fp,"%s", var->name);
46925 if (var->next) fprintf(fp,", ");
46926 }
46927 fprintf(fp," }\n");
46928 return 0;
46929 }
46930
46931 static PyObject *
46932 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46933 swig_globalvar *var = v->vars;
46934 while (var) {
46935 if (strcmp(var->name,n) == 0) {
46936 return (*var->get_attr)();
46937 }
46938 var = var->next;
46939 }
46940 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46941 return NULL;
46942 }
46943
46944 static int
46945 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46946 swig_globalvar *var = v->vars;
46947 while (var) {
46948 if (strcmp(var->name,n) == 0) {
46949 return (*var->set_attr)(p);
46950 }
46951 var = var->next;
46952 }
46953 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46954 return 1;
46955 }
46956
46957 static PyTypeObject varlinktype = {
46958 PyObject_HEAD_INIT(0)
46959 0, /* Number of items in variable part (ob_size) */
46960 (char *)"swigvarlink", /* Type name (tp_name) */
46961 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46962 0, /* Itemsize (tp_itemsize) */
46963 0, /* Deallocator (tp_dealloc) */
46964 (printfunc) swig_varlink_print, /* Print (tp_print) */
46965 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46966 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46967 0, /* tp_compare */
46968 (reprfunc) swig_varlink_repr, /* tp_repr */
46969 0, /* tp_as_number */
46970 0, /* tp_as_sequence */
46971 0, /* tp_as_mapping */
46972 0, /* tp_hash */
46973 0, /* tp_call */
46974 0, /* tp_str */
46975 0, /* tp_getattro */
46976 0, /* tp_setattro */
46977 0, /* tp_as_buffer */
46978 0, /* tp_flags */
46979 0, /* tp_doc */
46980 #if PY_VERSION_HEX >= 0x02000000
46981 0, /* tp_traverse */
46982 0, /* tp_clear */
46983 #endif
46984 #if PY_VERSION_HEX >= 0x02010000
46985 0, /* tp_richcompare */
46986 0, /* tp_weaklistoffset */
46987 #endif
46988 #if PY_VERSION_HEX >= 0x02020000
46989 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46990 #endif
46991 #if PY_VERSION_HEX >= 0x02030000
46992 0, /* tp_del */
46993 #endif
46994 #ifdef COUNT_ALLOCS
46995 0,0,0,0 /* tp_alloc -> tp_next */
46996 #endif
46997 };
46998
46999 /* Create a variable linking object for use later */
47000 static PyObject *
47001 SWIG_Python_newvarlink(void) {
47002 swig_varlinkobject *result = 0;
47003 result = PyMem_NEW(swig_varlinkobject,1);
47004 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47005 result->ob_type = &varlinktype;
47006 result->vars = 0;
47007 result->ob_refcnt = 0;
47008 Py_XINCREF((PyObject *) result);
47009 return ((PyObject*) result);
47010 }
47011
47012 static void
47013 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47014 swig_varlinkobject *v;
47015 swig_globalvar *gv;
47016 v= (swig_varlinkobject *) p;
47017 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47018 gv->name = (char *) malloc(strlen(name)+1);
47019 strcpy(gv->name,name);
47020 gv->get_attr = get_attr;
47021 gv->set_attr = set_attr;
47022 gv->next = v->vars;
47023 v->vars = gv;
47024 }
47025
47026 /* -----------------------------------------------------------------------------
47027 * constants/methods manipulation
47028 * ----------------------------------------------------------------------------- */
47029
47030 /* Install Constants */
47031 static void
47032 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47033 PyObject *obj = 0;
47034 size_t i;
47035 for (i = 0; constants[i].type; i++) {
47036 switch(constants[i].type) {
47037 case SWIG_PY_INT:
47038 obj = PyInt_FromLong(constants[i].lvalue);
47039 break;
47040 case SWIG_PY_FLOAT:
47041 obj = PyFloat_FromDouble(constants[i].dvalue);
47042 break;
47043 case SWIG_PY_STRING:
47044 if (constants[i].pvalue) {
47045 obj = PyString_FromString((char *) constants[i].pvalue);
47046 } else {
47047 Py_INCREF(Py_None);
47048 obj = Py_None;
47049 }
47050 break;
47051 case SWIG_PY_POINTER:
47052 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47053 break;
47054 case SWIG_PY_BINARY:
47055 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47056 break;
47057 default:
47058 obj = 0;
47059 break;
47060 }
47061 if (obj) {
47062 PyDict_SetItemString(d,constants[i].name,obj);
47063 Py_DECREF(obj);
47064 }
47065 }
47066 }
47067
47068 /* -----------------------------------------------------------------------------*/
47069 /* Fix SwigMethods to carry the callback ptrs when needed */
47070 /* -----------------------------------------------------------------------------*/
47071
47072 static void
47073 SWIG_Python_FixMethods(PyMethodDef *methods,
47074 swig_const_info *const_table,
47075 swig_type_info **types,
47076 swig_type_info **types_initial) {
47077 size_t i;
47078 for (i = 0; methods[i].ml_name; ++i) {
47079 char *c = methods[i].ml_doc;
47080 if (c && (c = strstr(c, "swig_ptr: "))) {
47081 int j;
47082 swig_const_info *ci = 0;
47083 char *name = c + 10;
47084 for (j = 0; const_table[j].type; j++) {
47085 if (strncmp(const_table[j].name, name,
47086 strlen(const_table[j].name)) == 0) {
47087 ci = &(const_table[j]);
47088 break;
47089 }
47090 }
47091 if (ci) {
47092 size_t shift = (ci->ptype) - types;
47093 swig_type_info *ty = types_initial[shift];
47094 size_t ldoc = (c - methods[i].ml_doc);
47095 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47096 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47097 char *buff = ndoc;
47098 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47099 strncpy(buff, methods[i].ml_doc, ldoc);
47100 buff += ldoc;
47101 strncpy(buff, "swig_ptr: ", 10);
47102 buff += 10;
47103 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47104 methods[i].ml_doc = ndoc;
47105 }
47106 }
47107 }
47108 }
47109
47110 /* -----------------------------------------------------------------------------*
47111 * Initialize type list
47112 * -----------------------------------------------------------------------------*/
47113
47114 #if PY_MAJOR_VERSION < 2
47115 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47116 is copied out of Python/modsupport.c in python version 2.3.4 */
47117 static int
47118 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47119 {
47120 PyObject *dict;
47121 if (!PyModule_Check(m)) {
47122 PyErr_SetString(PyExc_TypeError,
47123 "PyModule_AddObject() needs module as first arg");
47124 return -1;
47125 }
47126 if (!o) {
47127 PyErr_SetString(PyExc_TypeError,
47128 "PyModule_AddObject() needs non-NULL value");
47129 return -1;
47130 }
47131
47132 dict = PyModule_GetDict(m);
47133 if (dict == NULL) {
47134 /* Internal error -- modules must have a dict! */
47135 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47136 PyModule_GetName(m));
47137 return -1;
47138 }
47139 if (PyDict_SetItemString(dict, name, o))
47140 return -1;
47141 Py_DECREF(o);
47142 return 0;
47143 }
47144 #endif
47145
47146 static swig_type_info **
47147 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47148 static PyMethodDef swig_empty_runtime_method_table[] = {
47149 {
47150 NULL, NULL, 0, NULL
47151 }
47152 };/* Sentinel */
47153
47154 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47155 swig_empty_runtime_method_table);
47156 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47157 if (pointer && module) {
47158 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47159 }
47160 return type_list_handle;
47161 }
47162
47163 static swig_type_info **
47164 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47165 swig_type_info **type_pointer;
47166
47167 /* first check if module already created */
47168 type_pointer = SWIG_Python_GetTypeListHandle();
47169 if (type_pointer) {
47170 return type_pointer;
47171 } else {
47172 /* create a new module and variable */
47173 return SWIG_Python_SetTypeListHandle(type_list_handle);
47174 }
47175 }
47176
47177 #ifdef __cplusplus
47178 }
47179 #endif
47180
47181 /* -----------------------------------------------------------------------------*
47182 * Partial Init method
47183 * -----------------------------------------------------------------------------*/
47184
47185 #ifdef SWIG_LINK_RUNTIME
47186 #ifdef __cplusplus
47187 extern "C"
47188 #endif
47189 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47190 #endif
47191
47192 #ifdef __cplusplus
47193 extern "C"
47194 #endif
47195 SWIGEXPORT(void) SWIG_init(void) {
47196 static PyObject *SWIG_globals = 0;
47197 static int typeinit = 0;
47198 PyObject *m, *d;
47199 int i;
47200 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47201
47202 /* Fix SwigMethods to carry the callback ptrs when needed */
47203 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47204
47205 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47206 d = PyModule_GetDict(m);
47207
47208 if (!typeinit) {
47209 #ifdef SWIG_LINK_RUNTIME
47210 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47211 #else
47212 # ifndef SWIG_STATIC_RUNTIME
47213 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47214 # endif
47215 #endif
47216 for (i = 0; swig_types_initial[i]; i++) {
47217 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47218 }
47219 typeinit = 1;
47220 }
47221 SWIG_InstallConstants(d,swig_const_table);
47222
47223
47224 #ifndef wxPyUSE_EXPORT
47225 // Make our API structure a CObject so other modules can import it
47226 // from this module.
47227 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47228 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47229 Py_XDECREF(cobj);
47230 #endif
47231
47232 {
47233 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47234 }
47235 {
47236 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47237 }
47238 {
47239 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47240 }
47241 {
47242 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47243 }
47244 {
47245 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47246 }
47247 {
47248 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47249 }
47250 {
47251 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47252 }
47253 {
47254 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47255 }
47256 {
47257 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47258 }
47259 {
47260 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47261 }
47262 {
47263 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47264 }
47265 {
47266 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47267 }
47268 {
47269 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47270 }
47271 {
47272 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47273 }
47274 {
47275 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47276 }
47277 {
47278 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47279 }
47280 {
47281 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47282 }
47283 {
47284 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47285 }
47286 {
47287 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47288 }
47289 {
47290 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47291 }
47292 {
47293 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47294 }
47295 {
47296 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47297 }
47298 {
47299 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47300 }
47301 {
47302 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47303 }
47304 {
47305 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47306 }
47307 {
47308 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47309 }
47310 {
47311 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47312 }
47313 {
47314 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47315 }
47316 {
47317 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47318 }
47319 {
47320 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47321 }
47322 {
47323 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47324 }
47325 {
47326 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47327 }
47328 {
47329 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47330 }
47331 {
47332 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47333 }
47334 {
47335 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47336 }
47337 {
47338 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47339 }
47340 {
47341 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47342 }
47343 {
47344 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47345 }
47346 {
47347 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47348 }
47349 {
47350 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47351 }
47352 {
47353 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47354 }
47355 {
47356 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47357 }
47358 {
47359 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47360 }
47361 {
47362 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47363 }
47364 {
47365 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47366 }
47367 {
47368 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47369 }
47370 {
47371 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47372 }
47373 {
47374 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47375 }
47376 {
47377 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47378 }
47379 {
47380 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47381 }
47382 {
47383 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47384 }
47385 {
47386 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47387 }
47388 {
47389 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47390 }
47391 {
47392 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47393 }
47394 {
47395 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47396 }
47397 {
47398 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47399 }
47400 {
47401 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47402 }
47403 {
47404 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47405 }
47406 {
47407 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47408 }
47409 {
47410 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47411 }
47412 {
47413 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47414 }
47415 {
47416 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47417 }
47418 {
47419 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47420 }
47421 {
47422 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47423 }
47424 {
47425 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47426 }
47427 {
47428 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47429 }
47430 {
47431 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47432 }
47433 {
47434 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47435 }
47436 {
47437 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47438 }
47439 {
47440 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47441 }
47442 {
47443 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47444 }
47445 {
47446 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47447 }
47448 {
47449 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47450 }
47451 {
47452 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47453 }
47454 {
47455 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47456 }
47457 {
47458 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47459 }
47460 {
47461 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47462 }
47463 {
47464 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47465 }
47466 {
47467 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47468 }
47469 {
47470 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47471 }
47472 {
47473 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47474 }
47475 {
47476 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47477 }
47478 {
47479 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47480 }
47481 {
47482 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47483 }
47484 {
47485 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47486 }
47487 {
47488 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47489 }
47490 {
47491 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47492 }
47493 {
47494 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47495 }
47496 {
47497 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47498 }
47499 {
47500 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47501 }
47502 {
47503 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47504 }
47505 {
47506 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47507 }
47508 {
47509 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47510 }
47511 {
47512 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47513 }
47514 {
47515 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47516 }
47517 {
47518 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47519 }
47520 {
47521 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47522 }
47523 {
47524 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47525 }
47526 {
47527 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47528 }
47529 {
47530 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47531 }
47532 {
47533 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47534 }
47535 {
47536 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47537 }
47538 {
47539 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47540 }
47541 {
47542 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47543 }
47544 {
47545 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47546 }
47547 {
47548 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47549 }
47550 {
47551 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47552 }
47553 {
47554 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47555 }
47556 {
47557 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47558 }
47559 {
47560 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47561 }
47562 {
47563 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47564 }
47565 {
47566 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47567 }
47568 {
47569 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47570 }
47571 {
47572 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47573 }
47574 {
47575 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47576 }
47577 {
47578 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47579 }
47580 {
47581 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47582 }
47583 {
47584 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47585 }
47586 {
47587 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47588 }
47589 {
47590 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47591 }
47592 {
47593 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47594 }
47595 {
47596 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47597 }
47598 {
47599 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47600 }
47601 {
47602 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47603 }
47604 {
47605 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47606 }
47607 {
47608 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47609 }
47610 {
47611 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47612 }
47613 {
47614 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47615 }
47616 {
47617 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47618 }
47619 {
47620 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47621 }
47622 {
47623 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47624 }
47625 {
47626 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47627 }
47628 {
47629 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47630 }
47631 {
47632 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47633 }
47634 {
47635 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47636 }
47637 {
47638 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47639 }
47640 {
47641 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47642 }
47643 {
47644 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47645 }
47646 {
47647 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47648 }
47649 {
47650 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47651 }
47652 {
47653 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47654 }
47655 {
47656 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47657 }
47658 {
47659 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47660 }
47661 {
47662 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47663 }
47664 {
47665 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47666 }
47667 {
47668 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47669 }
47670 {
47671 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47672 }
47673 {
47674 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47675 }
47676 {
47677 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47678 }
47679 {
47680 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47681 }
47682 {
47683 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47684 }
47685 {
47686 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47687 }
47688 {
47689 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47690 }
47691 {
47692 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48836 }
48837 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48838 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48839 {
48840 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48991 }
48992 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48993 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48994 {
48995 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49002 }
49003
49004 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49005
49006
49007 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49008
49009 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49010 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49011 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49012 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49013 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49014 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49015 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49016 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49017 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49018 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49019 {
49020 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49024 }
49025 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49026 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49027 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49028 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49029 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49030 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49031 {
49032 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49078 }
49079 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49080 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49081 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49082 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49083 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49084 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49085 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49086 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49087 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49088 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49089 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49090 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49091 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49092 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49093 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49094 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49095 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49096 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49097 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49098 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49099 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49100 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49101 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49102 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49103 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49104 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49105 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49106 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49107 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49108 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49109 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49110 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49111 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49112 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49113 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49114 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49115 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49116 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49117 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49118 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49119 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49120 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49121 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49122 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49123 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49124 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49125 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49126 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49127 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49128 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49129 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49130 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49131 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49132 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49133 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49134 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49135 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49136 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49137 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49138 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49139 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49140 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49141 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49142 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49143 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49144 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49145 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49146 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49147 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49148 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49149 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49150 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49151 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49152 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49153 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49154 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49155 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49156 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49157 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49158 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49159 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49160 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49161 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49162 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49163 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49164 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49165 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49166 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49167 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49168 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49169 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49170 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49171 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49172 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49173 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49174 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49175 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49176 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49177 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49178 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49179 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49180 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49181 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49182 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49183 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49184 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49185 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49186 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49187 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49188 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49189 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49190 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49191 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49192 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49193 {
49194 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49231 }
49232 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49233 {
49234 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49250 }
49251 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49252 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49253 {
49254 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49267 }
49268 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49269 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49270 {
49271 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49278 }
49279 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49280 {
49281 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49336 }
49337
49338 // Initialize threading, some globals and such
49339 __wxPyPreStart(d);
49340
49341
49342 // Although these are defined in __version__ they need to be here too so
49343 // that an assert can be done to ensure that the wxPython and the wxWindows
49344 // versions match.
49345 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49346 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49347 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49348
49349 }
49350
wxWidgets (Impactor)